@helpwave/hightide 0.8.12 → 0.9.1

package/dist/index.d.mts

@@ -1,9 +1,10 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as react from 'react';
-import react__default, { HTMLAttributes, SVGProps, ReactNode, PropsWithChildren, RefObject, CSSProperties, Dispatch, SetStateAction, ButtonHTMLAttributes, InputHTMLAttributes, ComponentProps, TableHTMLAttributes, TextareaHTMLAttributes, LabelHTMLAttributes } from 'react';
-import { TableFeature, ColumnDef, Table as Table$1, InitialTableState, Row, TableState, TableOptions, RowData, FilterFn, RowSelectionState, RowModel, Column, SortDirection, ColumnSizingState } from '@tanstack/react-table';
+import react__default, { HTMLAttributes, SVGProps, ReactNode, PropsWithChildren, RefObject, CSSProperties, Dispatch, SetStateAction, ButtonHTMLAttributes, InputHTMLAttributes, ComponentPropsWithoutRef, ComponentProps, JSX, TableHTMLAttributes, TextareaHTMLAttributes, LabelHTMLAttributes, ElementType } from 'react';
 import { Translation, TranslationEntries, PartialTranslationExtension } from '@helpwave/internationalization';
 import Link from 'next/link';
+import { TableFeature, ColumnDef, Table as Table$1, InitialTableState, Row, TableState, TableOptions, RowData, FilterFn, RowSelectionState, RowModel, Header, SortDirection, ColumnSizingState, ColumnFilter } from '@tanstack/react-table';
+import { SlotProps } from '@radix-ui/react-slot';
 
 type Size = 'sm' | 'md' | 'lg';
 type HelpwaveBadgeProps = HTMLAttributes<HTMLSpanElement> & {
@@ -50,7 +51,7 @@ type AvatarGroupProps = HTMLAttributes<HTMLDivElement> & {
 declare const AvatarGroup: ({ avatars, showTotalNumber, size, ...props }: AvatarGroupProps) => react_jsx_runtime.JSX.Element;
 
 type ChipSize = 'xs' | 'sm' | 'md' | 'lg' | null;
-type ChipColoringStyle = 'solid' | 'tonal' | null;
+type ChipColoringStyle = 'solid' | 'tonal' | 'outline' | 'tonal-outline' | null;
 declare const chipColors: readonly ["primary", "secondary", "positive", "warning", "negative", "neutral"];
 type ChipColor = typeof chipColors[number];
 declare const ChipUtil: {
@@ -499,44 +500,6 @@ interface InfiniteScrollProps {
 }
 declare function InfiniteScroll({ children, itemCount, bufferSize, scrollThreshold, stepSize, initialIndex, className, style, }: InfiniteScrollProps): react_jsx_runtime.JSX.Element;
 
-type ListBoxItemProps = HTMLAttributes<HTMLLIElement> & {
-    value: string;
-    disabled?: boolean;
-};
-declare const ListBoxItem: react__default.ForwardRefExoticComponent<HTMLAttributes<HTMLLIElement> & {
-    value: string;
-    disabled?: boolean;
-} & react__default.RefAttributes<HTMLLIElement>>;
-type ListBoxOrientation = 'vertical' | 'horizontal';
-type ListBoxPrimitiveProps = HTMLAttributes<HTMLUListElement> & {
-    value?: string[];
-    initialValue?: string[];
-    onItemClicked?: (value: string) => void;
-    onSelectionChanged?: (value: string[]) => void;
-    isSelection?: boolean;
-    isMultiple?: boolean;
-    orientation?: ListBoxOrientation;
-};
-declare const ListBoxPrimitive: react__default.ForwardRefExoticComponent<HTMLAttributes<HTMLUListElement> & {
-    value?: string[];
-    initialValue?: string[];
-    onItemClicked?: (value: string) => void;
-    onSelectionChanged?: (value: string[]) => void;
-    isSelection?: boolean;
-    isMultiple?: boolean;
-    orientation?: ListBoxOrientation;
-} & react__default.RefAttributes<HTMLUListElement>>;
-type ListBoxMultipleProps = Omit<ListBoxPrimitiveProps, 'isMultiple'>;
-declare const ListBoxMultiple: ({ ...props }: ListBoxMultipleProps) => react_jsx_runtime.JSX.Element;
-type ListBoxProps = Omit<ListBoxPrimitiveProps, 'isMultiple' | 'value' | 'onSelectionChanged'> & {
-    value?: string;
-    onSelectionChanged?: (value: string) => void;
-};
-declare const ListBox: react__default.ForwardRefExoticComponent<Omit<ListBoxPrimitiveProps, "value" | "onSelectionChanged" | "isMultiple"> & {
-    value?: string;
-    onSelectionChanged?: (value: string) => void;
-} & react__default.RefAttributes<HTMLUListElement>>;
-
 type ASTNodeModifierType = 'none' | 'italic' | 'bold' | 'underline' | 'font-space' | 'primary' | 'secondary' | 'warn' | 'positive' | 'negative';
 declare const astNodeInserterType: readonly ["helpwave", "newline"];
 type ASTNodeInserterType = typeof astNodeInserterType[number];
@@ -722,7 +685,7 @@ declare function DialogRoot({ children, isOpen: controlledIsOpen, onIsOpenChange
  * The different sizes for a button
  */
 type ButtonSize = 'xs' | 'sm' | 'md' | 'lg' | null;
-type ButtonColoringStyle = 'outline' | 'solid' | 'text' | 'tonal' | null;
+type ButtonColoringStyle = 'outline' | 'solid' | 'text' | 'tonal' | 'tonal-outline' | null;
 declare const buttonColorsList: readonly ["primary", "secondary", "positive", "warning", "negative", "neutral"];
 /**
  * The allowed colors for the Button
@@ -835,69 +798,134 @@ type InputModalProps = ConfirmDialogProps & {
  */
 declare const InputDialog: ({ inputs, buttonOverwrites, ...props }: InputModalProps) => react_jsx_runtime.JSX.Element;
 
-type RegisteredOption = {
-    value: string;
-    label: ReactNode;
-    disabled: boolean;
-    ref: React.RefObject<HTMLLIElement>;
-};
-type HighlightStartPositionBehavior = 'first' | 'last';
-type SelectIconAppearance = 'left' | 'right' | 'none';
-type InternalSelectContextState = {
+interface SelectIds {
+    trigger: string;
+    content: string;
+    listbox: string;
+    searchInput: string;
+}
+interface SelectRootProps<T> extends Partial<FormFieldDataHandling<T>>, Partial<FormFieldInteractionStates> {
+    value?: T | null;
+    initialValue?: T | null;
+    compareFunction?: (a: T | null, b: T | null) => boolean;
+    initialIsOpen?: boolean;
+    onClose?: () => void;
+    onIsOpenChange?: (isOpen: boolean) => void;
+    showSearch?: boolean;
+    iconAppearance?: 'left' | 'right' | 'none';
+    children: ReactNode;
+}
+declare function SelectRoot<T>({ children, value, onValueChange, onEditComplete, initialValue, compareFunction, initialIsOpen, onClose, onIsOpenChange, showSearch, iconAppearance, invalid, disabled, readOnly, required, }: SelectRootProps<T>): react_jsx_runtime.JSX.Element;
+
+interface UseSelectOption {
+    id: string;
+    label?: string;
+    disabled?: boolean;
+}
+interface UseSelectOptions {
+    options: ReadonlyArray<UseSelectOption>;
+    value?: string | null;
+    initialValue?: string | null;
+    initialIsOpen?: boolean;
+    onValueChange?: (value: string) => void;
+    onEditComplete?: (value: string) => void;
+    onClose?: () => void;
+    onIsOpenChange?: (isOpen: boolean) => void;
+    typeAheadResetMs?: number;
+}
+type UseSelectFirstHighlightBehavior = 'first' | 'last';
+interface UseSelectState {
+    value: string | null;
+    highlightedValue: string | undefined;
     isOpen: boolean;
-    options: RegisteredOption[];
-    highlightedValue?: string;
-};
-type SelectContextIds = {
+    searchQuery: string;
+    options: ReadonlyArray<UseSelectOption>;
+}
+interface UseSelectComputedState {
+    visibleOptionIds: ReadonlyArray<string>;
+}
+interface UseSelectActions {
+    setIsOpen: (isOpen: boolean, behavior?: UseSelectFirstHighlightBehavior) => void;
+    toggleOpen: (behavior?: UseSelectFirstHighlightBehavior) => void;
+    setSearchQuery: (query: string) => void;
+    highlightFirst: () => void;
+    highlightLast: () => void;
+    highlightNext: () => void;
+    highlightPrevious: () => void;
+    highlightItem: (value: string) => void;
+    selectValue: (value: string) => void;
+    handleTypeaheadKey: (key: string) => void;
+}
+interface UseSelectReturn extends UseSelectState, UseSelectComputedState, UseSelectActions {
+}
+declare function useSelect({ options, value: controlledValue, onValueChange, onEditComplete, initialValue, onClose, onIsOpenChange, initialIsOpen, typeAheadResetMs, }: UseSelectOptions): UseSelectReturn;
+
+interface SelectOptionType<T = string> {
+    id: string;
+    value: T;
+    label?: string;
+    display?: ReactNode;
+    disabled?: boolean;
+    ref: RefObject<HTMLElement>;
+}
+interface SelectContextIds {
     trigger: string;
     content: string;
-};
-type SelectContextState = InternalSelectContextState & FormFieldInteractionStates & {
-    value: string[];
-    selectedOptions: RegisteredOption[];
-};
-type SelectConfiguration = {
-    isMultiSelect: boolean;
+    listbox: string;
+    searchInput: string;
+}
+interface SelectContextState<T> extends FormFieldInteractionStates {
+    selectedId: string | null;
+    options: ReadonlyArray<SelectOptionType<T>>;
+    highlightedId: string | null;
+    isOpen: boolean;
+}
+interface SelectContextComputedState<T> {
+    visibleOptionIds: ReadonlyArray<string>;
+    idToOptionMap: Record<string, SelectOptionType<T>>;
+}
+interface SelectContextActions<T> {
+    registerOption(option: SelectOptionType<T>): () => void;
+    toggleSelection(id: string): void;
+    highlightFirst(): void;
+    highlightLast(): void;
+    highlightNext(): void;
+    highlightPrevious(): void;
+    highlightItem(id: string): void;
+    handleTypeaheadKey(key: string): void;
+    setIsOpen(open: boolean, behavior?: UseSelectFirstHighlightBehavior): void;
+    toggleIsOpen(behavior?: UseSelectFirstHighlightBehavior): void;
+}
+interface SelectContextLayout {
+    triggerRef: RefObject<HTMLElement>;
+    registerTrigger(element: RefObject<HTMLElement>): () => void;
+}
+interface SelectContextSearch {
+    hasSearch: boolean;
+    searchQuery?: string;
+    setSearchQuery(query: string): void;
+}
+type SelectIconAppearance = 'left' | 'right' | 'none';
+interface SelectContextConfig {
     iconAppearance: SelectIconAppearance;
-};
-type ToggleOpenOptions = {
-    highlightStartPositionBehavior?: HighlightStartPositionBehavior;
-};
-type SelectContextType = {
     ids: SelectContextIds;
     setIds: Dispatch<SetStateAction<SelectContextIds>>;
-    state: SelectContextState;
-    config: SelectConfiguration;
-    item: {
-        register: (item: RegisteredOption) => void;
-        unregister: (value: string) => void;
-        toggleSelection: (value: string, isSelected?: boolean) => void;
-        highlightItem: (value: string) => void;
-        moveHighlightedIndex: (delta: number) => void;
-    };
-    trigger: {
-        ref: React.RefObject<HTMLElement>;
-        register: (element: React.RefObject<HTMLElement>) => void;
-        unregister: () => void;
-        toggleOpen: (isOpen?: boolean, options?: ToggleOpenOptions) => void;
-    };
-};
-declare const SelectContext: react.Context<SelectContextType>;
-declare function useSelectContext(): SelectContextType;
-type SharedSelectRootProps = Partial<FormFieldInteractionStates> & PropsWithChildren & {
-    id?: string;
-    initialIsOpen?: boolean;
-    iconAppearance?: SelectIconAppearance;
-    onClose?: () => void;
-};
-type SelectRootProps = SharedSelectRootProps & Partial<FormFieldDataHandling<string>> & {
-    initialValue?: string;
-};
-declare const SelectRoot: ({ value, onValueChange, onEditComplete, ...props }: SelectRootProps) => react_jsx_runtime.JSX.Element;
-type MultiSelectRootProps = SharedSelectRootProps & Partial<FormFieldDataHandling<string[]>> & {
-    initialValue?: string[];
-};
-declare const MultiSelectRoot: ({ value, onValueChange, initialValue, onEditComplete, ...props }: MultiSelectRootProps) => react_jsx_runtime.JSX.Element;
+}
+interface SelectContextType<T> extends SelectContextActions<T>, SelectContextState<T>, SelectContextComputedState<T> {
+    config: SelectContextConfig;
+    layout: SelectContextLayout;
+    search: SelectContextSearch;
+}
+declare const SelectContext: react.Context<SelectContextType<unknown>>;
+declare function useSelectContext<T>(): SelectContextType<T>;
+
+interface SelectButtonProps<T = string> extends ComponentPropsWithoutRef<'div'> {
+    placeholder?: ReactNode;
+    disabled?: boolean;
+    selectedDisplay?: (value: SelectOptionType<T> | null) => ReactNode;
+    hideExpansionIcon?: boolean;
+}
+declare const SelectButton: react.ForwardRefExoticComponent<SelectButtonProps<unknown> & react.RefAttributes<HTMLDivElement>>;
 
 type UseFocusTrapProps = {
     container: RefObject<HTMLElement>;
@@ -920,76 +948,30 @@ declare const useOutsideClick: ({ refs, onOutsideClick, active }: UseOutsideClic
 interface PopUpProps extends AnchoredFloatingContainerProps, Partial<UseOutsideClickHandlers> {
     isOpen?: boolean;
     focusTrapOptions?: Omit<UseFocusTrapProps, 'container'>;
-    outsideClickOptions?: UseOutsideClickOptions;
+    outsideClickOptions?: Partial<UseOutsideClickOptions>;
     onClose?: () => void;
     forceMount?: boolean;
     anchorExcludedFromOutsideClick?: boolean;
 }
-declare const PopUp: react.ForwardRefExoticComponent<PopUpProps & react.RefAttributes<HTMLDivElement>>;
+declare const PopUp: react.ForwardRefExoticComponent<PopUpProps & react.RefAttributes<HTMLElement>>;
 
-type SelectOptionProps = Omit<HTMLAttributes<HTMLLIElement>, 'children'> & {
-    value: string;
-    disabled?: boolean;
-    iconAppearance?: SelectIconAppearance;
-    children?: ReactNode;
-};
-declare const SelectOption: react.ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLLIElement>, "children"> & {
-    value: string;
-    disabled?: boolean;
-    iconAppearance?: SelectIconAppearance;
-    children?: ReactNode;
-} & react.RefAttributes<HTMLLIElement>>;
-type SelectButtonProps = ButtonHTMLAttributes<HTMLButtonElement> & {
-    placeholder?: ReactNode;
-    selectedDisplay?: (value: string[]) => ReactNode;
-    hideExpansionIcon?: boolean;
-};
-declare const SelectButton: react.ForwardRefExoticComponent<ButtonHTMLAttributes<HTMLButtonElement> & {
-    placeholder?: ReactNode;
-    selectedDisplay?: (value: string[]) => ReactNode;
-    hideExpansionIcon?: boolean;
-} & react.RefAttributes<HTMLButtonElement>>;
-type SelectContentProps = PopUpProps;
-declare const SelectContent: react.ForwardRefExoticComponent<PopUpProps & react.RefAttributes<HTMLUListElement>>;
-type MultiSelectOptionProps = SelectOptionProps;
-declare const MultiSelectOption: react.ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLLIElement>, "children"> & {
-    value: string;
-    disabled?: boolean;
-    iconAppearance?: SelectIconAppearance;
-    children?: ReactNode;
-} & react.RefAttributes<HTMLLIElement>>;
-type MultiSelectContentProps = SelectContentProps;
-declare const MultiSelectContent: react.ForwardRefExoticComponent<PopUpProps & react.RefAttributes<HTMLUListElement>>;
-type MultiSelectButtonProps = SelectButtonProps;
-declare const MultiSelectButton: react.ForwardRefExoticComponent<ButtonHTMLAttributes<HTMLButtonElement> & {
-    placeholder?: ReactNode;
-    selectedDisplay?: (value: string[]) => ReactNode;
-    hideExpansionIcon?: boolean;
-} & react.RefAttributes<HTMLButtonElement>>;
+interface SelectContentProps extends PopUpProps {
+    showSearch?: boolean;
+    searchInputProps?: Omit<ComponentProps<typeof Input>, 'value' | 'onValueChange'>;
+}
+declare const SelectContent: react.ForwardRefExoticComponent<SelectContentProps & react.RefAttributes<HTMLUListElement>>;
 
-type SelectProps = SelectRootProps & {
+type SelectProps<T = string> = SelectRootProps<T> & {
     contentPanelProps?: SelectContentProps;
-    buttonProps?: Omit<SelectButtonProps, 'selectedDisplay'> & {
-        selectedDisplay?: (value: string) => ReactNode;
+    buttonProps?: Omit<SelectButtonProps<T>, 'selectedDisplay'> & {
+        selectedDisplay?: (value: SelectOptionType<T> | null) => ReactNode;
+    } & {
+        [key: string]: unknown;
     };
 };
-declare const Select: react.ForwardRefExoticComponent<Partial<FormFieldInteractionStates> & {
-    children?: ReactNode | undefined;
-} & {
-    id?: string;
-    initialIsOpen?: boolean;
-    iconAppearance?: SelectIconAppearance;
-    onClose?: () => void;
-} & Partial<FormFieldDataHandling<string>> & {
-    initialValue?: string;
-} & {
-    contentPanelProps?: SelectContentProps;
-    buttonProps?: Omit<SelectButtonProps, "selectedDisplay"> & {
-        selectedDisplay?: (value: string) => ReactNode;
-    };
-} & react.RefAttributes<HTMLButtonElement>>;
+declare const Select: <T>(props: SelectProps<T> & React.RefAttributes<HTMLDivElement>) => JSX.Element;
 
-type LanguageSelectProps = Omit<SelectProps, 'value'>;
+type LanguageSelectProps = Omit<SelectProps, 'value' | 'children'>;
 declare const LanguageSelect: ({ ...props }: LanguageSelectProps) => react_jsx_runtime.JSX.Element;
 type LanguageDialogProps = Omit<DialogProps, 'titleElement' | 'description'> & PropsWithChildren<{
     titleOverwrite?: ReactNode;
@@ -1006,6 +988,7 @@ declare const hightideTranslationLocales: readonly ["de-DE", "en-US"];
 type HightideTranslationLocales = typeof hightideTranslationLocales[number];
 type HightideTranslationEntries = {
     'add': string;
+    'addFilter': string;
     'after': string;
     'age': string;
     'all': string;
@@ -1047,6 +1030,7 @@ type HightideTranslationEntries = {
     'discardChanges': string;
     'done': string;
     'edit': string;
+    'editFilter': string;
     'endDate': string;
     'endsWith': string;
     'enterText': string;
@@ -1060,6 +1044,7 @@ type HightideTranslationEntries = {
     'filter': string;
     'filterNonWhitespace': string;
     'filterNotUndefined': string;
+    'filterOptions': string;
     'filterUndefined': string;
     'first': string;
     'goodToSeeYou': string;
@@ -1071,7 +1056,9 @@ type HightideTranslationEntries = {
     'invalidEmail': string;
     'invalidEmailError': string;
     'isFalse': string;
+    'isNotUndefined': string;
     'isTrue': string;
+    'isUndefined': string;
     'language': string;
     'last': string;
     'less': string;
@@ -1096,6 +1083,9 @@ type HightideTranslationEntries = {
     'notEmpty': string;
     'notEquals': string;
     'nothingFound': string;
+    'nResultsFound': (values: {
+        count: number;
+    }) => string;
     'of': string;
     'onOrAfter': string;
     'onOrBefore': string;
@@ -1123,19 +1113,59 @@ type HightideTranslationEntries = {
     'pThemes': (values: {
         count: number;
     }) => string;
+    'rBetween': (values: {
+        value1: string;
+        value2: string;
+    }) => string;
+    'rContains': (values: {
+        value: string;
+    }) => string;
     'remove': string;
+    'removeFilter': string;
     'removeProperty': string;
+    'rEndsWith': (values: {
+        value: string;
+    }) => string;
+    'rEquals': (values: {
+        value: string;
+    }) => string;
     'required': string;
     'reset': string;
+    'rGreaterThan': (values: {
+        value: string;
+    }) => string;
+    'rGreaterThanOrEqual': (values: {
+        value: string;
+    }) => string;
+    'rLessThan': (values: {
+        value: string;
+    }) => string;
+    'rLessThanOrEqual': (values: {
+        value: string;
+    }) => string;
+    'rNotBetween': (values: {
+        value1: string;
+        value2: string;
+    }) => string;
+    'rNotContains': (values: {
+        value: string;
+    }) => string;
+    'rNotEquals': (values: {
+        value: string;
+    }) => string;
     'rSortingOrderAfter': (values: {
         otherSortings: number;
     }) => string;
+    'rStartsWith': (values: {
+        value: string;
+    }) => string;
     'save': string;
     'saved': string;
     'sDateTimeSelect': (values: {
         datetimeMode: string;
     }) => string;
     'search': string;
+    'searchResults': string;
     'select': string;
     'selection': string;
     'selectOption': string;
@@ -1243,6 +1273,7 @@ type HightideTranslationEntries = {
     'tooShort': (values: {
         min: number;
     }) => string;
+    'unknown': string;
     'unpin': string;
     'unsavedChanges': string;
     'unsavedChangesSaveQuestion': string;
@@ -1322,7 +1353,7 @@ interface ThemeIconProps extends HTMLAttributes<SVGSVGElement> {
     theme?: ThemeType;
 }
 declare const ThemeIcon: ({ theme: themeOverride, ...props }: ThemeIconProps) => react_jsx_runtime.JSX.Element;
-type ThemeSelectProps = Omit<SelectProps, 'value'>;
+type ThemeSelectProps = Omit<SelectProps<ThemeType>, 'value' | 'children'>;
 declare const ThemeSelect: ({ ...props }: ThemeSelectProps) => react_jsx_runtime.JSX.Element;
 interface ThemeDialogProps extends Omit<DialogProps, 'titleElement' | 'description'> {
     titleOverwrite?: ReactNode;
@@ -1423,7 +1454,7 @@ declare const Tooltip: ({ tooltip, children, isInitiallyShown, appearDelay, disa
  * The different sizes for a icon button
  */
 type IconButtonSize = 'xs' | 'sm' | 'md' | 'lg' | null;
-type IconButtonColoringStyle = 'outline' | 'solid' | 'text' | 'tonal' | null;
+type IconButtonColoringStyle = 'outline' | 'solid' | 'text' | 'tonal' | 'tonal-outline' | null;
 interface IconButtonBaseProps extends ButtonHTMLAttributes<HTMLButtonElement> {
     /**
      * @default 'medium'
@@ -1433,7 +1464,6 @@ interface IconButtonBaseProps extends ButtonHTMLAttributes<HTMLButtonElement> {
      * @default 'solid'
      */
     coloringStyle?: IconButtonColoringStyle;
-    allowClickEventPropagation?: boolean;
 }
 declare const IconButtonBase: react.ForwardRefExoticComponent<IconButtonBaseProps & react.RefAttributes<HTMLButtonElement>>;
 interface IconButtonProps extends IconButtonBaseProps {
@@ -1645,7 +1675,8 @@ declare module '@tanstack/react-table' {
         filterData?: {
             tags?: {
                 tag: string;
-                label: ReactNode;
+                label: string;
+                display?: ReactNode;
             }[];
         };
         columnLabel?: string;
@@ -1662,7 +1693,7 @@ declare module '@tanstack/react-table' {
         boolean: FilterFn<unknown>;
         multiTags: FilterFn<unknown>;
         singleTag: FilterFn<unknown>;
-        generic: FilterFn<unknown>;
+        unknownType: FilterFn<unknown>;
     }
     interface TableOptions<TData extends RowData> {
         columnSizingTarget?: number;
@@ -1688,7 +1719,7 @@ declare const TableDisplay: <T>({ children, containerProps, tableHeaderProps, ..
 
 type TablePaginationMenuProps = Omit<PaginationProps, 'pageIndex' | 'pageCount'>;
 declare const TablePaginationMenu: ({ ...props }: TablePaginationMenuProps) => react_jsx_runtime.JSX.Element;
-interface TablePageSizeSelectProps extends SelectProps {
+interface TablePageSizeSelectProps extends Omit<SelectProps, 'children'> {
     pageSizeOptions?: number[];
 }
 declare const TablePageSizeSelect: ({ pageSizeOptions, ...props }: TablePageSizeSelectProps) => react_jsx_runtime.JSX.Element;
@@ -1733,101 +1764,25 @@ type TableCellProps = PropsWithChildren<{
 }>;
 declare const TableCell: ({ children, className, }: TableCellProps) => react_jsx_runtime.JSX.Element;
 
-declare const TableFilterOperator: {
-    readonly text: readonly ["textEquals", "textNotEquals", "textNotWhitespace", "textContains", "textNotContains", "textStartsWith", "textEndsWith"];
-    readonly number: readonly ["numberEquals", "numberNotEquals", "numberGreaterThan", "numberGreaterThanOrEqual", "numberLessThan", "numberLessThanOrEqual", "numberBetween", "numberNotBetween"];
-    readonly date: readonly ["dateEquals", "dateNotEquals", "dateGreaterThan", "dateGreaterThanOrEqual", "dateLessThan", "dateLessThanOrEqual", "dateBetween", "dateNotBetween"];
-    readonly dateTime: readonly ["dateTimeEquals", "dateTimeNotEquals", "dateTimeGreaterThan", "dateTimeGreaterThanOrEqual", "dateTimeLessThan", "dateTimeLessThanOrEqual", "dateTimeBetween", "dateTimeNotBetween"];
-    readonly boolean: readonly ["booleanIsTrue", "booleanIsFalse"];
-    readonly multiTags: readonly ["tagsEquals", "tagsNotEquals", "tagsContains", "tagsNotContains"];
-    readonly singleTag: readonly ["tagsSingleEquals", "tagsSingleNotEquals", "tagsSingleContains", "tagsSingleNotContains"];
-    readonly generic: readonly ["undefined", "notUndefined"];
-};
-type TableGenericFilter = (typeof TableFilterOperator.generic)[number];
-type TableTextFilter = (typeof TableFilterOperator.text)[number] | TableGenericFilter;
-type TableNumberFilter = (typeof TableFilterOperator.number)[number] | TableGenericFilter;
-type TableDateFilter = (typeof TableFilterOperator.date)[number] | TableGenericFilter;
-type TableDatetimeFilter = (typeof TableFilterOperator.dateTime)[number] | TableGenericFilter;
-type TableBooleanFilter = (typeof TableFilterOperator.boolean)[number] | TableGenericFilter;
-type TableTagsFilter = (typeof TableFilterOperator.multiTags)[number] | TableGenericFilter;
-type TableTagsSingleFilter = (typeof TableFilterOperator.singleTag)[number] | TableGenericFilter;
-type TableFilterType = TableTextFilter | TableNumberFilter | TableDateFilter | TableDatetimeFilter | TableBooleanFilter | TableTagsFilter | TableTagsSingleFilter | TableGenericFilter;
-type TableFilterCategory = keyof typeof TableFilterOperator;
-declare function isTableFilterCategory(value: unknown): value is TableFilterCategory;
-type TextFilterParameter = {
-    searchText?: string;
-    isCaseSensitive?: boolean;
-};
-type NumberFilterParameter = {
-    compareValue?: number;
-    min?: number;
-    max?: number;
-};
-type DateFilterParameter = {
-    compareDate?: Date;
-    min?: Date;
-    max?: Date;
-};
-type DatetimeFilterParameter = {
-    compareDatetime?: Date;
-    min?: Date;
-    max?: Date;
-};
-type BooleanFilterParameter = Record<string, never>;
-type TagsFilterParameter = {
-    searchTags?: unknown[];
-};
-type TagsSingleFilterParameter = {
-    searchTag?: unknown;
-    searchTagsContains?: unknown[];
-};
-type GenericFilterParameter = Record<string, never>;
-type TextFilterValue = {
-    operator: TableTextFilter;
-    parameter: TextFilterParameter;
-};
-type NumberFilterValue = {
-    operator: TableNumberFilter;
-    parameter: NumberFilterParameter;
-};
-type DateFilterValue = {
-    operator: TableDateFilter;
-    parameter: DateFilterParameter;
-};
-type DatetimeFilterValue = {
-    operator: TableDatetimeFilter;
-    parameter: DatetimeFilterParameter;
-};
-type BooleanFilterValue = {
-    operator: TableBooleanFilter;
-    parameter: BooleanFilterParameter;
-};
-type TagsFilterValue = {
-    operator: TableTagsFilter;
-    parameter: TagsFilterParameter;
-};
-type TagsSingleFilterValue = {
-    operator: TableTagsSingleFilter;
-    parameter: TagsSingleFilterParameter;
-};
-type GenericFilterValue = {
-    operator: TableGenericFilter;
-    parameter: GenericFilterParameter;
-};
-type TableFilterValue = TextFilterValue | NumberFilterValue | DateFilterValue | DatetimeFilterValue | BooleanFilterValue | TagsFilterValue | TagsSingleFilterValue | GenericFilterValue;
-declare const TableFilter: {
-    text: FilterFn<unknown>;
-    number: FilterFn<unknown>;
-    date: FilterFn<unknown>;
-    dateTime: FilterFn<unknown>;
-    boolean: FilterFn<unknown>;
-    multiTags: FilterFn<unknown>;
-    singleTag: FilterFn<unknown>;
-    generic: FilterFn<unknown>;
+declare const dataTypes: readonly ["text", "number", "date", "dateTime", "boolean", "singleTag", "multiTags", "unknownType"];
+type DataType = (typeof dataTypes)[number];
+interface DataValue {
+    textValue?: string;
+    numberValue?: number;
+    booleanValue?: boolean;
+    dateValue?: Date;
+    singleSelectValue?: string;
+    multiSelectValue?: string[];
+}
+declare function toIcon(type: DataType): ReactNode;
+declare const DataTypeUtils: {
+    types: readonly ["text", "number", "date", "dateTime", "boolean", "singleTag", "multiTags", "unknownType"];
+    getDefaultValue: (type: DataType, selectOptions?: string[]) => DataValue;
+    toIcon: typeof toIcon;
 };
 
 type TableColumnProps<T> = ColumnDef<T> & {
-    filterType?: TableFilterCategory;
+    filterType?: DataType;
 };
 declare const TableColumn: <T>(props: TableColumnProps<T>) => react_jsx_runtime.JSX.Element;
 
@@ -1888,41 +1843,22 @@ type TableColumnDefinitionContextType<T> = {
 declare const TableColumnDefinitionContext: react.Context<TableColumnDefinitionContextType<any>>;
 declare const useTableColumnDefinitionContext: <T>() => TableColumnDefinitionContextType<T>;
 
-type TableFilterButtonProps<T = unknown> = {
-    filterType: TableFilterCategory;
-    column: Column<T>;
-};
-declare const TableFilterButton: <T>({ filterType, column, }: TableFilterButtonProps<T>) => react_jsx_runtime.JSX.Element;
-
-interface TableFilterBaseProps<T extends TableFilterValue> {
-    columnId: string;
-    filterValue?: T | undefined;
-    onFilterValueChange: (value: T | undefined) => void;
-}
-type OperatorLabelProps = {
-    operator: TableFilterType;
-};
-declare const OperatorLabel: ({ operator }: OperatorLabelProps) => react_jsx_runtime.JSX.Element;
-type TextFilterProps = TableFilterBaseProps<TextFilterValue>;
-declare const TextFilter: ({ filterValue, onFilterValueChange }: TextFilterProps) => react_jsx_runtime.JSX.Element;
-type NumberFilterProps = TableFilterBaseProps<NumberFilterValue>;
-declare const NumberFilter: ({ filterValue, onFilterValueChange }: NumberFilterProps) => react_jsx_runtime.JSX.Element;
-type DateFilterProps = TableFilterBaseProps<DateFilterValue>;
-declare const DateFilter: ({ filterValue, onFilterValueChange }: DateFilterProps) => react_jsx_runtime.JSX.Element;
-type DatetimeFilterProps = TableFilterBaseProps<DatetimeFilterValue>;
-declare const DatetimeFilter: ({ filterValue, onFilterValueChange }: DatetimeFilterProps) => react_jsx_runtime.JSX.Element;
-type BooleanFilterProps = TableFilterBaseProps<BooleanFilterValue>;
-declare const BooleanFilter: ({ filterValue, onFilterValueChange }: BooleanFilterProps) => react_jsx_runtime.JSX.Element;
-type TagsFilterProps = TableFilterBaseProps<TagsFilterValue>;
-declare const TagsFilter: ({ columnId, filterValue, onFilterValueChange }: TagsFilterProps) => react_jsx_runtime.JSX.Element;
-type TagsSingleFilterProps = TableFilterBaseProps<TagsSingleFilterValue>;
-declare const TagsSingleFilter: ({ columnId, filterValue, onFilterValueChange }: TagsSingleFilterProps) => react_jsx_runtime.JSX.Element;
-type GenericFilterProps = TableFilterBaseProps<GenericFilterValue>;
-declare const GenericFilter: ({ filterValue, onFilterValueChange }: GenericFilterProps) => react_jsx_runtime.JSX.Element;
-interface TableFilterContentProps extends TableFilterBaseProps<TableFilterValue> {
-    filterType: TableFilterCategory;
-}
-declare const TableFilterContent: ({ filterType, ...props }: TableFilterContentProps) => react_jsx_runtime.JSX.Element;
+declare const TableFilter: {
+    text: FilterFn<unknown>;
+    number: FilterFn<unknown>;
+    date: FilterFn<unknown>;
+    dateTime: FilterFn<unknown>;
+    boolean: FilterFn<unknown>;
+    multiTags: FilterFn<unknown>;
+    singleTag: FilterFn<unknown>;
+    unknownType: FilterFn<unknown>;
+};
+
+type TableFilterButtonProps = {
+    filterType: DataType;
+    header: Header<unknown, unknown>;
+};
+declare const TableFilterButton: ({ filterType, header, }: TableFilterButtonProps) => react_jsx_runtime.JSX.Element;
 
 type SortingIndexDisplay = {
     index: number;
@@ -1973,6 +1909,116 @@ type CheckboxProps = HTMLAttributes<HTMLDivElement> & Partial<FormFieldInteracti
  */
 declare const Checkbox: ({ value: controlledValue, initialValue, indeterminate, required, invalid, disabled, readOnly, onValueChange, onEditComplete, size, alwaysShowCheckIcon, ...props }: CheckboxProps) => react_jsx_runtime.JSX.Element;
 
+type ComboboxInputProps = Omit<ComponentProps<typeof Input>, 'value'>;
+declare const ComboboxInput: react.ForwardRefExoticComponent<Omit<ComboboxInputProps, "ref"> & react.RefAttributes<HTMLInputElement>>;
+
+type ComboboxListProps = HTMLAttributes<HTMLUListElement>;
+declare const ComboboxList: react.ForwardRefExoticComponent<ComboboxListProps & react.RefAttributes<HTMLUListElement>>;
+
+interface ComboboxProps<T = string> {
+    children: ReactNode;
+    onItemClick?: (value: T) => void;
+    id?: string;
+    searchQuery?: string;
+    onSearchQueryChange?: (value: string) => void;
+    initialSearchQuery?: string;
+    inputProps?: ComboboxInputProps;
+    listProps?: ComboboxListProps;
+}
+declare const Combobox: <T = string>(props: ComboboxProps<T> & React.RefAttributes<HTMLDivElement>) => JSX.Element;
+
+interface ComboboxOptionType<T = string> {
+    id: string;
+    value: T;
+    label?: string;
+    display?: ReactNode;
+    disabled?: boolean;
+    ref: RefObject<HTMLElement>;
+}
+interface ComboboxContextIds {
+    trigger: string;
+    listbox: string;
+}
+interface ComboboxContextInternalState {
+    highlightedId: string | null;
+}
+interface ComboboxContextComputedState<T> {
+    options: ReadonlyArray<ComboboxOptionType<T>>;
+    visibleOptionIds: ReadonlyArray<string>;
+    idToOptionMap: Record<string, ComboboxOptionType<T>>;
+}
+interface ComboboxContextActions<T> {
+    registerOption(option: ComboboxOptionType<T>): () => void;
+    selectOption(id: string): void;
+    highlightFirst(): void;
+    highlightLast(): void;
+    highlightNext(): void;
+    highlightPrevious(): void;
+    highlightItem(id: string): void;
+}
+interface ComboboxContextLayout {
+    listRef: RefObject<HTMLUListElement | null>;
+    registerList(ref: RefObject<HTMLUListElement | null>): () => void;
+}
+interface ComboboxContextSearch {
+    searchQuery: string;
+    setSearchQuery(query: string): void;
+}
+interface ComboboxContextConfig {
+    ids: ComboboxContextIds;
+    setIds: Dispatch<SetStateAction<ComboboxContextIds>>;
+}
+interface ComboboxContextType<T> extends ComboboxContextInternalState, ComboboxContextComputedState<T>, ComboboxContextActions<T> {
+    config: ComboboxContextConfig;
+    layout: ComboboxContextLayout;
+    search: ComboboxContextSearch;
+}
+declare const ComboboxContext: react.Context<ComboboxContextType<unknown>>;
+declare function useComboboxContext<T = string>(): ComboboxContextType<T>;
+
+interface ComboboxOptionProps<T = string> extends HTMLAttributes<HTMLLIElement> {
+    value: T;
+    label: string;
+    disabled?: boolean;
+}
+declare const ComboboxOption: react.ForwardRefExoticComponent<ComboboxOptionProps<unknown> & react.RefAttributes<HTMLLIElement>>;
+
+interface UseComboboxOption {
+    id: string;
+    label?: string;
+    disabled?: boolean;
+}
+interface UseComboboxOptions {
+    options: ReadonlyArray<UseComboboxOption>;
+    searchQuery?: string;
+    onSearchQueryChange?: (query: string) => void;
+    initialSearchQuery?: string;
+}
+interface UseComboboxState {
+    searchQuery: string;
+    highlightedId: string | null;
+}
+interface UseComboboxComputedState {
+    visibleOptionIds: ReadonlyArray<string>;
+}
+interface UseComboboxActions {
+    setSearchQuery: (query: string) => void;
+    highlightFirst: () => void;
+    highlightLast: () => void;
+    highlightNext: () => void;
+    highlightPrevious: () => void;
+    highlightItem: (id: string) => void;
+}
+interface UseComboboxReturn extends UseComboboxState, UseComboboxComputedState, UseComboboxActions {
+}
+declare function useCombobox({ options, searchQuery: controlledSearchQuery, onSearchQueryChange, initialSearchQuery, }: UseComboboxOptions): UseComboboxReturn;
+
+interface ComboboxRootProps<T = string> extends Omit<UseComboboxOptions, 'options'> {
+    children: ReactNode;
+    onItemClick?: (value: T) => void;
+}
+declare function ComboboxRoot<T = string>({ children, onItemClick, ...hookProps }: ComboboxRootProps<T>): react_jsx_runtime.JSX.Element;
+
 interface CopyToClipboardWrapperProps extends Omit<TooltipProps, 'tooltip'> {
     textToCopy: string;
 }
@@ -2003,6 +2049,177 @@ interface MenuProps extends Omit<PopUpProps, 'children' | 'anchor'> {
  */
 declare const Menu: ({ trigger, children, disabled, ...props }: MenuProps) => react_jsx_runtime.JSX.Element;
 
+interface UseMultiSelectOption {
+    id: string;
+    label?: string;
+    disabled?: boolean;
+}
+interface UseMultiSelectOptions {
+    options: ReadonlyArray<UseMultiSelectOption>;
+    value?: ReadonlyArray<string>;
+    onValueChange?: (value: string[]) => void;
+    onEditComplete?: (value: string[]) => void;
+    initialValue?: string[];
+    initialIsOpen?: boolean;
+    onClose?: () => void;
+    typeAheadResetMs?: number;
+}
+type UseMultiSelectFirstHighlightBehavior = 'first' | 'last';
+interface UseMultiSelectState {
+    value: string[];
+    highlightedId: string | null;
+    isOpen: boolean;
+    searchQuery: string;
+    options: ReadonlyArray<UseMultiSelectOption>;
+}
+interface UseMultiSelectComputedState {
+    visibleOptionIds: ReadonlyArray<string>;
+}
+interface UseMultiSelectActions {
+    setIsOpen: (isOpen: boolean, behavior?: UseMultiSelectFirstHighlightBehavior) => void;
+    toggleOpen: (behavior?: UseMultiSelectFirstHighlightBehavior) => void;
+    setSearchQuery: (query: string) => void;
+    highlightFirst: () => void;
+    highlightLast: () => void;
+    highlightNext: () => void;
+    highlightPrevious: () => void;
+    highlightItem: (id: string) => void;
+    toggleSelection: (id: string, isSelected?: boolean) => void;
+    setSelection: (ids: string[]) => void;
+    isSelected: (id: string) => boolean;
+    handleTypeaheadKey: (key: string) => void;
+}
+interface UseMultiSelectReturn extends UseMultiSelectState, UseMultiSelectComputedState, UseMultiSelectActions {
+}
+declare function useMultiSelect({ options, value: controlledValue, onValueChange, onEditComplete, initialValue, onClose, initialIsOpen, typeAheadResetMs, }: UseMultiSelectOptions): UseMultiSelectReturn;
+
+interface MultiSelectOptionType<T = string> {
+    id: string;
+    value: T;
+    label?: string;
+    display?: ReactNode;
+    disabled?: boolean;
+    ref: RefObject<HTMLElement>;
+}
+interface MultiSelectContextIds {
+    trigger: string;
+    content: string;
+    listbox: string;
+    searchInput: string;
+}
+interface MultiSelectContextState<T> extends FormFieldInteractionStates {
+    value: T[];
+    options: ReadonlyArray<MultiSelectOptionType<T>>;
+    selectedIds: string[];
+    highlightedId: string | null;
+    isOpen: boolean;
+}
+interface MultiSelectContextComputedState<T> {
+    visibleOptionIds: ReadonlyArray<string>;
+    idToOptionMap: Record<string, MultiSelectOptionType<T>>;
+}
+interface MultiSelectContextActions<T> {
+    registerOption(option: MultiSelectOptionType<T>): () => void;
+    toggleSelection(id: string, isSelected?: boolean): void;
+    highlightFirst(): void;
+    highlightLast(): void;
+    highlightNext(): void;
+    highlightPrevious(): void;
+    highlightItem(id: string): void;
+    handleTypeaheadKey(key: string): void;
+    setIsOpen(open: boolean, behavior?: UseMultiSelectFirstHighlightBehavior): void;
+    toggleIsOpen(behavior?: UseMultiSelectFirstHighlightBehavior): void;
+}
+interface MultiSelectContextLayout {
+    triggerRef: RefObject<HTMLElement>;
+    registerTrigger(element: RefObject<HTMLElement>): () => void;
+}
+interface MultiSelectContextSearch {
+    hasSearch: boolean;
+    searchQuery?: string;
+    setSearchQuery(query: string): void;
+}
+type MultiSelectIconAppearance = 'left' | 'right' | 'none';
+interface MultiSelectContextConfig {
+    iconAppearance: MultiSelectIconAppearance;
+    ids: MultiSelectContextIds;
+    setIds: Dispatch<SetStateAction<MultiSelectContextIds>>;
+}
+interface MultiSelectContextType<T> extends MultiSelectContextActions<T>, MultiSelectContextState<T>, MultiSelectContextComputedState<T> {
+    config: MultiSelectContextConfig;
+    layout: MultiSelectContextLayout;
+    search: MultiSelectContextSearch;
+}
+declare const MultiSelectContext: react.Context<MultiSelectContextType<unknown>>;
+declare function useMultiSelectContext<T>(): MultiSelectContextType<T>;
+
+interface MultiSelectIds {
+    trigger: string;
+    content: string;
+    listbox: string;
+    searchInput: string;
+}
+interface MultiSelectRootProps<T> extends Partial<FormFieldDataHandling<T[]>>, Partial<FormFieldInteractionStates> {
+    initialValue?: T[];
+    compareFunction?: (a: T, b: T) => boolean;
+    initialIsOpen?: boolean;
+    onClose?: () => void;
+    showSearch?: boolean;
+    iconAppearance?: MultiSelectIconAppearance;
+    children: ReactNode;
+}
+declare function MultiSelectRoot<T>({ children, value, onValueChange, onEditComplete, initialValue, compareFunction, initialIsOpen, onClose, showSearch, iconAppearance, invalid, disabled, readOnly, required, }: MultiSelectRootProps<T>): react_jsx_runtime.JSX.Element;
+
+interface MultiSelectButtonProps<T = string> extends ComponentPropsWithoutRef<'div'> {
+    placeholder?: ReactNode;
+    disabled?: boolean;
+    selectedDisplay?: (values: T[]) => ReactNode;
+    hideExpansionIcon?: boolean;
+}
+declare const MultiSelectButton: react.ForwardRefExoticComponent<MultiSelectButtonProps<unknown> & react.RefAttributes<HTMLDivElement>>;
+
+interface MultiSelectContentProps extends PopUpProps {
+    showSearch?: boolean;
+    searchInputProps?: Omit<ComponentProps<typeof Input>, 'value' | 'onValueChange'>;
+}
+declare const MultiSelectContent: react.ForwardRefExoticComponent<MultiSelectContentProps & react.RefAttributes<HTMLUListElement>>;
+
+interface MultiSelectProps<T = string> extends MultiSelectRootProps<T> {
+    contentPanelProps?: MultiSelectContentProps;
+    buttonProps?: MultiSelectButtonProps<T>;
+}
+declare const MultiSelect: <T = string>(props: MultiSelectProps<T> & {
+    ref?: React.Ref<HTMLDivElement>;
+}) => React.ReactElement;
+
+type MultiSelectChipDisplayButtonProps = HTMLAttributes<HTMLDivElement> & {
+    disabled?: boolean;
+    placeholder?: ReactNode;
+};
+declare const MultiSelectChipDisplayButton: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
+    disabled?: boolean;
+    placeholder?: ReactNode;
+} & react.RefAttributes<HTMLDivElement>>;
+type MultiSelectChipDisplayProps<T = string> = MultiSelectRootProps<T> & {
+    contentPanelProps?: MultiSelectContentProps;
+    chipDisplayProps?: MultiSelectChipDisplayButtonProps;
+};
+declare const MultiSelectChipDisplay: react.ForwardRefExoticComponent<MultiSelectRootProps<unknown> & {
+    contentPanelProps?: MultiSelectContentProps;
+    chipDisplayProps?: MultiSelectChipDisplayButtonProps;
+} & react.RefAttributes<HTMLDivElement>>;
+
+type MultiSelectOptionDisplayLocation = 'trigger' | 'list';
+declare const MultiSelectOptionDisplayContext: react.Context<MultiSelectOptionDisplayLocation>;
+declare function useMultiSelectOptionDisplayLocation(): MultiSelectOptionDisplayLocation;
+interface MultiSelectOptionProps<T = string> extends HTMLAttributes<HTMLLIElement> {
+    value: T;
+    label: string;
+    disabled?: boolean;
+    iconAppearance?: MultiSelectIconAppearance;
+}
+declare const MultiSelectOption: react.ForwardRefExoticComponent<MultiSelectOptionProps<unknown> & react.RefAttributes<HTMLLIElement>>;
+
 type ScrollPickerProps<T> = {
     options: T[];
     mapping: (value: T) => string;
@@ -2015,6 +2232,17 @@ type ScrollPickerProps<T> = {
  */
 declare const ScrollPicker: <T>({ options, mapping, selected, onChange, disabled, }: ScrollPickerProps<T>) => react_jsx_runtime.JSX.Element;
 
+type SelectOptionDisplayLocation = 'trigger' | 'list';
+declare const SelectOptionDisplayContext: react.Context<SelectOptionDisplayLocation>;
+declare function useSelectOptionDisplayLocation(): SelectOptionDisplayLocation;
+interface SelectOptionProps<T = string> extends HTMLAttributes<HTMLLIElement> {
+    value: T;
+    label: string;
+    disabled?: boolean;
+    iconAppearance?: SelectIconAppearance;
+}
+declare const SelectOption: react.ForwardRefExoticComponent<SelectOptionProps<unknown> & react.RefAttributes<HTMLLIElement>>;
+
 type SwitchProps = HTMLAttributes<HTMLDivElement> & Partial<FormFieldInteractionStates> & Partial<FormFieldDataHandling<boolean>> & {
     initialValue?: boolean;
 };
@@ -2045,25 +2273,191 @@ type TextareaWithHeadlineProps = Omit<TextareaProps, 'defaultStyle'> & {
 };
 declare const TextareaWithHeadline: ({ id, headline, headlineProps, disabled, className, containerClassName, ...props }: TextareaWithHeadlineProps) => react_jsx_runtime.JSX.Element;
 
-type DurationJSON = {
-    years: number;
-    months: number;
-    days: number;
-    hours: number;
-    minutes: number;
-    seconds: number;
-    milliseconds: number;
+declare const filterOperators: readonly ["equals", "notEquals", "contains", "notContains", "startsWith", "endsWith", "greaterThan", "greaterThanOrEqual", "lessThan", "lessThanOrEqual", "between", "notBetween", "isTrue", "isFalse", "isUndefined", "isNotUndefined"];
+type FilterOperator = (typeof filterOperators)[number];
+declare const filterOperatorsByCategory: Record<DataType, FilterOperator[]>;
+type FilterOperatorUnknownType = (typeof filterOperatorsByCategory.unknownType)[number];
+type FilterOperatorText = (typeof filterOperatorsByCategory.text)[number];
+type FilterOperatorNumber = (typeof filterOperatorsByCategory.number)[number];
+type FilterOperatorDate = (typeof filterOperatorsByCategory.date)[number];
+type FilterOperatorDatetime = (typeof filterOperatorsByCategory.dateTime)[number];
+type FilterOperatorBoolean = (typeof filterOperatorsByCategory.boolean)[number];
+type FilterOperatorTags = (typeof filterOperatorsByCategory.multiTags)[number];
+type FilterOperatorTagsSingle = (typeof filterOperatorsByCategory.singleTag)[number];
+declare function isFilterOperatorText(value: unknown): value is FilterOperatorText;
+declare function isFilterOperatorNumber(value: unknown): value is FilterOperatorNumber;
+declare function isFilterOperatorDate(value: unknown): value is FilterOperatorDate;
+declare function isFilterOperatorDatetime(value: unknown): value is FilterOperatorDatetime;
+declare function isFilterOperatorBoolean(value: unknown): value is FilterOperatorBoolean;
+declare function isFilterOperatorTags(value: unknown): value is FilterOperatorTags;
+declare function isFilterOperatorTagsSingle(value: unknown): value is FilterOperatorTagsSingle;
+declare function isFilterOperatorUnknownType(value: unknown): value is FilterOperatorUnknownType;
+declare function isFilterOperator(value: unknown): value is FilterOperator;
+type OperatorInfoResult = {
+    icon: ReactNode;
+    translationKey: string;
+    replacementTranslationKey: string;
+};
+declare function getDefaultOperator(dataType: DataType): FilterOperator;
+declare const FilterOperatorUtils: {
+    operators: readonly ["equals", "notEquals", "contains", "notContains", "startsWith", "endsWith", "greaterThan", "greaterThanOrEqual", "lessThan", "lessThanOrEqual", "between", "notBetween", "isTrue", "isFalse", "isUndefined", "isNotUndefined"];
+    operatorsByCategory: Record<"number" | "boolean" | "text" | "date" | "dateTime" | "multiTags" | "singleTag" | "unknownType", ("endsWith" | "startsWith" | "between" | "contains" | "equals" | "greaterThan" | "greaterThanOrEqual" | "isFalse" | "isNotUndefined" | "isTrue" | "isUndefined" | "lessThan" | "lessThanOrEqual" | "notBetween" | "notContains" | "notEquals")[]>;
+    getInfo: (operator: FilterOperator) => OperatorInfoResult;
+    getDefaultOperator: typeof getDefaultOperator;
+    typeCheck: {
+        all: typeof isFilterOperator;
+        text: typeof isFilterOperatorText;
+        number: typeof isFilterOperatorNumber;
+        date: typeof isFilterOperatorDate;
+        datetime: typeof isFilterOperatorDatetime;
+        boolean: typeof isFilterOperatorBoolean;
+        tags: typeof isFilterOperatorTags;
+        tagsSingle: typeof isFilterOperatorTagsSingle;
+        unknownType: typeof isFilterOperatorUnknownType;
+    };
 };
-declare class Duration {
-    readonly years: number;
-    readonly months: number;
-    readonly days: number;
-    readonly hours: number;
-    readonly minutes: number;
-    readonly seconds: number;
-    readonly milliseconds: number;
-    constructor({ years, months, days, hours, minutes, seconds, milliseconds, }?: Partial<DurationJSON>);
-    /** Date arithmetic */
+
+type FilterParameter = {
+    searchText?: string;
+    isCaseSensitive?: boolean;
+    compareValue?: number;
+    minNumber?: number;
+    maxNumber?: number;
+    compareDate?: Date;
+    minDate?: Date;
+    maxDate?: Date;
+    multiOptionSearch?: unknown[];
+    singleOptionSearch?: unknown;
+};
+type FilterValue = {
+    dataType: DataType;
+    operator: FilterOperator;
+    parameter: FilterParameter;
+};
+declare function isFilterValueValid(value: FilterValue): boolean;
+declare const FilterValueUtils: {
+    allowedOperatorsByDataType: Record<"number" | "boolean" | "text" | "date" | "dateTime" | "multiTags" | "singleTag" | "unknownType", ("endsWith" | "startsWith" | "between" | "contains" | "equals" | "greaterThan" | "greaterThanOrEqual" | "isFalse" | "isNotUndefined" | "isTrue" | "isUndefined" | "lessThan" | "lessThanOrEqual" | "notBetween" | "notContains" | "notEquals")[]>;
+    isValid: typeof isFilterValueValid;
+};
+declare const FilterFunctions: Record<DataType, (value: unknown, operator: FilterOperator, parameter: FilterParameter) => boolean>;
+type FilterValueTranslationOptions = {
+    tags?: ReadonlyArray<{
+        tag: string;
+        label: string;
+    }>;
+};
+declare function useFilterValueTranslation(): (value: FilterValue, options?: FilterValueTranslationOptions) => string;
+
+interface IdentifierFilterValue extends ColumnFilter {
+    value: FilterValue;
+}
+interface FilterListPopUpBuilderProps {
+    value: FilterValue;
+    onValueChange: (value: FilterValue) => void;
+    onRemove: () => void;
+    dataType: DataType;
+    tags: ReadonlyArray<{
+        tag: string;
+        label: string;
+        display?: ReactNode;
+    }>;
+    name: string;
+    isOpen: boolean;
+    close: () => void;
+}
+interface FilterListItem {
+    id: string;
+    label: string;
+    dataType: DataType;
+    tags: ReadonlyArray<{
+        tag: string;
+        label: string;
+        display?: ReactNode;
+    }>;
+    popUpBuilder?: (props: FilterListPopUpBuilderProps) => ReactNode;
+}
+interface FilterListProps {
+    value: IdentifierFilterValue[];
+    onValueChange: (value: IdentifierFilterValue[]) => void;
+    availableItems: FilterListItem[];
+}
+declare const FilterList: ({ value, onValueChange, availableItems }: FilterListProps) => react_jsx_runtime.JSX.Element;
+
+type FilterOperatorLabelProps = {
+    operator: FilterOperator;
+};
+declare const FilterOperatorLabel: ({ operator }: FilterOperatorLabelProps) => react_jsx_runtime.JSX.Element;
+
+interface FilterPopUpProps extends PopUpProps {
+    name?: ReactNode;
+    value?: FilterValue;
+    onValueChange: (value: FilterValue) => void;
+    onRemove: () => void;
+}
+interface FilterPopUpBaseProps extends PopUpProps {
+    /**
+     * The name of the object/column the filter is applied to
+     */
+    name?: ReactNode;
+    operator: FilterOperator;
+    onOperatorChange: (operator: FilterOperator) => void;
+    onRemove: () => void;
+    allowedOperators: FilterOperator[];
+    hasValue: boolean;
+    noParameterRequired?: boolean;
+}
+declare const FilterBasePopUp: react.ForwardRefExoticComponent<FilterPopUpBaseProps & react.RefAttributes<HTMLDivElement>>;
+declare const TextFilterPopUp: react.ForwardRefExoticComponent<FilterPopUpProps & react.RefAttributes<HTMLDivElement>>;
+declare const NumberFilterPopUp: react.ForwardRefExoticComponent<FilterPopUpProps & react.RefAttributes<HTMLDivElement>>;
+declare const DateFilterPopUp: react.ForwardRefExoticComponent<FilterPopUpProps & react.RefAttributes<HTMLDivElement>>;
+declare const DatetimeFilterPopUp: react.ForwardRefExoticComponent<FilterPopUpProps & react.RefAttributes<HTMLDivElement>>;
+declare const BooleanFilterPopUp: react.ForwardRefExoticComponent<FilterPopUpProps & react.RefAttributes<HTMLDivElement>>;
+interface TagsFilterPopUpProps extends FilterPopUpProps {
+    tags: ReadonlyArray<{
+        tag: string;
+        label: string;
+        display?: ReactNode;
+    }>;
+}
+declare const TagsFilterPopUp: react.ForwardRefExoticComponent<TagsFilterPopUpProps & react.RefAttributes<HTMLDivElement>>;
+interface TagsSingleFilterPopUpProps extends FilterPopUpProps {
+    tags: ReadonlyArray<{
+        tag: string;
+        label: string;
+        display?: ReactNode;
+    }>;
+}
+declare const TagsSingleFilterPopUp: react.ForwardRefExoticComponent<TagsSingleFilterPopUpProps & react.RefAttributes<HTMLDivElement>>;
+declare const GenericFilterPopUp: react.ForwardRefExoticComponent<FilterPopUpProps & react.RefAttributes<HTMLDivElement>>;
+interface DataTypeFilterPopUpProps extends FilterPopUpProps {
+    dataType: DataType;
+    tags: ReadonlyArray<{
+        tag: string;
+        label: string;
+        display?: ReactNode;
+    }>;
+}
+declare const FilterPopUp: react.ForwardRefExoticComponent<DataTypeFilterPopUpProps & react.RefAttributes<HTMLDivElement>>;
+
+type DurationJSON = {
+    years: number;
+    months: number;
+    days: number;
+    hours: number;
+    minutes: number;
+    seconds: number;
+    milliseconds: number;
+};
+declare class Duration {
+    readonly years: number;
+    readonly months: number;
+    readonly days: number;
+    readonly hours: number;
+    readonly minutes: number;
+    readonly seconds: number;
+    readonly milliseconds: number;
+    constructor({ years, months, days, hours, minutes, seconds, milliseconds, }?: Partial<DurationJSON>);
+    /** Date arithmetic */
     addTo(date: Date): Date;
     subtractFrom(date: Date): Date;
     /** Duration arithmetic */
@@ -2085,6 +2479,9 @@ declare const monthsList: readonly ["january", "february", "march", "april", "ma
 type Month = typeof monthsList[number];
 declare const weekDayList: readonly ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];
 type WeekDay = typeof weekDayList[number];
+declare function tryParseDate(dateValue: Date | string | number | undefined | null): Date | null;
+declare function normalizeToDateOnly(date: Date): Date;
+declare function normalizeDatetime(dateTime: Date): Date;
 declare const DateUtils: {
     monthsList: readonly ["january", "february", "march", "april", "may", "june", "july", "august", "september", "october", "november", "december"];
     weekDayList: readonly ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];
@@ -2105,6 +2502,12 @@ declare const DateUtils: {
         readonly yearImprecise: 31557600;
     };
     toInputString: (date: Date, format: DateTimeFormat, precision?: DateTimePrecision, isLocalTime?: boolean) => string;
+    tryParseDate: typeof tryParseDate;
+    toOnlyDate: typeof normalizeToDateOnly;
+    /**
+     * Normalizes a datetime by removing seconds and milliseconds.
+     */
+    toDateTimeOnly: typeof normalizeDatetime;
 };
 
 type DayPickerProps = Partial<FormFieldDataHandling<Date>> & {
@@ -2144,266 +2547,6 @@ interface DatePickerProps extends Partial<FormFieldDataHandling<Date>>, Pick<Day
  */
 declare const DatePicker: ({ value: controlledValue, initialValue, start, end, initialDisplay, weekStart, onValueChange, onEditComplete, yearMonthPickerProps, dayPickerProps, className }: DatePickerProps) => react_jsx_runtime.JSX.Element;
 
-type StorageSubscriber = (raw: string | null) => void;
-declare class StorageListener {
-    private static instance;
-    private localSubscriptions;
-    private sessionSubscriptions;
-    private initialized;
-    private constructor();
-    static getInstance(): StorageListener;
-    subscribe(storage: Storage, key: string, cb: StorageSubscriber): () => void;
-    private init;
-    private handleEvent;
-    private getRegistry;
-}
-
-declare const equalSizeGroups: <T>(array: T[], groupSize: number) => T[][];
-type RangeOptions = {
-    /**  Whether the range can be defined empty via end < start without a warning */
-    allowEmptyRange: boolean;
-    stepSize: number;
-    exclusiveStart: boolean;
-    exclusiveEnd: boolean;
-};
-/**
- * @param endOrRange The end value or a range [start, end], end is exclusive
- * @param options the options for defining the range
- */
-declare const range: (endOrRange: number | [number, number], options?: Partial<RangeOptions>) => number[];
-/** Finds the closest match
- * @param list The list of all possible matches
- * @param firstCloser Return whether item1 is closer than item2
- */
-declare const closestMatch: <T>(list: T[], firstCloser: (item1: T, item2: T) => boolean) => T;
-/**
- * returns the item in middle of a list and its neighbours before and after
- * e.g. [1,2,3,4,5,6] for item = 1 would return [5,6,1,2,3]
- */
-declare const getNeighbours: <T>(list: T[], item: T, neighbourDistance?: number) => T[];
-declare const createLoopingListWithIndex: <T>(list: T[], startIndex?: number, length?: number, forwards?: boolean) => [number, T][];
-declare const createLoopingList: <T>(list: T[], startIndex?: number, length?: number, forwards?: boolean) => T[];
-declare function resolveSingleOrArray<T>(value: T | T[]): T[];
-declare const ArrayUtil: {
-    unique: <T>(list: T[]) => T[];
-    difference: <T>(list: T[], removeList: T[]) => T[];
-    moveItems: <T>(list: T[], move?: number) => any[];
-    resolveSingleOrArray: typeof resolveSingleOrArray;
-};
-
-type BagFunction<B, V = ReactNode> = (bag: B) => V;
-type BagFunctionOrValue<B, V> = BagFunction<B, V> | V;
-type BagFunctionOrNode<B> = BagFunction<B> | ReactNode;
-type PropsWithBagFunction<B, P = unknown> = P & {
-    children?: BagFunction<B>;
-};
-type PropsWithBagFunctionOrChildren<B, P = unknown> = P & {
-    children?: BagFunctionOrNode<B>;
-};
-declare const BagFunctionUtil: {
-    resolve: <B, V = ReactNode>(bagFunctionOrValue: BagFunctionOrValue<B, V>, bag: B) => V;
-};
-
-/**
- * A simple function that implements the builder pattern
- * @param value The value to update which gets return with the same reference
- * @param update The updates to apply on the object
- */
-declare const builder: <T>(value: T, update: (value: T) => void) => T;
-
-type EaseFunction = (t: number) => number;
-declare class EaseFunctions {
-    static cubicBezierGeneric(x1: number, y1: number, x2: number, y2: number): {
-        x: EaseFunction;
-        y: EaseFunction;
-    };
-    static cubicBezier(x1: number, y1: number, x2: number, y2: number): EaseFunction;
-    static easeInEaseOut(t: number): number;
-}
-
-declare const validateEmail: (email: string) => boolean;
-
-/**
- * Filters a text value based on the provided filter value.
- */
-declare function filterText(value: unknown, filterValue: TextFilterValue): boolean;
-/**
- * Filters a number value based on the provided filter value.
- */
-declare function filterNumber(value: unknown, filterValue: NumberFilterValue): boolean;
-/**
- * Filters a date value based on the provided filter value.
- * Only compares dates, ignoring time components.
- */
-declare function filterDate(value: unknown, filterValue: DateFilterValue): boolean;
-/**
- * Filters a dateTime value based on the provided filter value.
- */
-declare function filterDatetime(value: unknown, filterValue: DatetimeFilterValue): boolean;
-/**
- * Filters a boolean value based on the provided filter value.
- */
-declare function filterBoolean(value: unknown, filterValue: BooleanFilterValue): boolean;
-/**
- * Filters a tags array value based on the provided filter value.
- */
-declare function filterTags(value: unknown, filterValue: TagsFilterValue): boolean;
-/**
- * Filters a single tag value based on the provided filter value.
- */
-declare function filterTagsSingle(value: unknown, filterValue: TagsSingleFilterValue): boolean;
-/**
- * Filters a generic value based on the provided filter value.
- */
-declare function filterGeneric(value: unknown, filterValue: GenericFilterValue): boolean;
-
-/**
- *  1 is forwards
- *
- * -1 is backwards
- */
-type Direction = 1 | -1;
-declare class LoopingArrayCalculator {
-    length: number;
-    isLooping: boolean;
-    allowedOverScroll: number;
-    constructor(length: number, isLooping?: boolean, allowedOverScroll?: number);
-    getCorrectedPosition(position: number): number;
-    static withoutOffset(position: number): number;
-    static getOffset(position: number): number;
-    /**
-     * @return absolute distance forwards or Infinity when the target cannot be reached (only possible when not isLooping)
-     */
-    getDistanceDirectional(position: number, target: number, direction: Direction): number;
-    getDistanceForward(position: number, target: number): number;
-    getDistanceBackward(position: number, target: number): number;
-    getDistance(position: number, target: number): number;
-    getBestDirection(position: number, target: number): Direction;
-}
-
-declare const match: <K extends string | number | symbol, V>(key: K, values: Record<K, V>) => Record<K, V>[K];
-
-type Range = [number, number];
-type UnBoundedRange = [undefined | number, undefined | number];
-declare function clamp(value: number, min: number, max: number): number;
-declare function clamp(value: number, range?: [number, number]): number;
-declare const MathUtil: {
-    clamp: typeof clamp;
-};
-
-declare const noop: () => any;
-
-declare function sleep(ms: number): Promise<void>;
-declare function delayed<T>(value: T, ms: number): Promise<T>;
-declare const PromiseUtils: {
-    sleep: typeof sleep;
-    delayed: typeof delayed;
-};
-
-declare function bool(isActive: boolean): string | undefined;
-type InteractionStateDataAttributes = {
-    'data-disabled': string | undefined;
-    'data-invalid': string | undefined;
-    'data-readonly': string | undefined;
-    'data-required': string | undefined;
-};
-declare function interactionStatesData(interactionStates: Partial<FormFieldInteractionStates>): Partial<InteractionStateDataAttributes>;
-type MouseEventExtenderProps<T> = {
-    fromProps?: react__default.MouseEventHandler<T>;
-    extensions: SingleOrArray<react__default.MouseEventHandler<T>>;
-};
-declare function mouseEventExtender<T>({ fromProps, extensions }: MouseEventExtenderProps<T>): react__default.MouseEventHandler<T>;
-type KeyoardEventExtenderProps<T> = {
-    fromProps: react__default.KeyboardEventHandler<T>;
-    extensions: SingleOrArray<react__default.KeyboardEventHandler<T>>;
-};
-declare function keyboardEventExtender<T>({ fromProps, extensions, }: KeyoardEventExtenderProps<T>): react__default.KeyboardEventHandler<T>;
-declare function click<T>(onClick: () => void): {
-    onClick: () => void;
-    onKeyDown: react__default.KeyboardEventHandler<T>;
-};
-declare function close<T>(onClose?: () => void): react__default.KeyboardEventHandler<T>;
-type NavigateType<T> = {
-    left?: (event: react__default.KeyboardEvent<T>) => void;
-    right?: (event: react__default.KeyboardEvent<T>) => void;
-    up?: (event: react__default.KeyboardEvent<T>) => void;
-    down?: (event: react__default.KeyboardEvent<T>) => void;
-};
-declare function navigate<T>({ left, right, up, down, }: NavigateType<T>): react__default.KeyboardEventHandler<T>;
-declare function mergeProps<T extends object, U extends Partial<T>>(slotProps: T, childProps: U): T & U;
-type InteractionStateARIAAttributes = Pick<HTMLAttributes<HTMLDivElement>, 'aria-disabled' | 'aria-invalid' | 'aria-readonly' | 'aria-required'>;
-declare function interactionStatesAria(interactionStates: Partial<FormFieldInteractionStates>, props?: Partial<InteractionStateARIAAttributes>): Partial<InteractionStateARIAAttributes>;
-declare const PropsUtil: {
-    extender: {
-        mouseEvent: typeof mouseEventExtender;
-        keyboardEvent: typeof keyboardEventExtender;
-    };
-    dataAttributes: {
-        bool: typeof bool;
-        interactionStates: typeof interactionStatesData;
-    };
-    aria: {
-        close: typeof close;
-        click: typeof click;
-        navigate: typeof navigate;
-        interactionStates: typeof interactionStatesAria;
-    };
-    mergeProps: typeof mergeProps;
-};
-
-declare function resolveSetState<T>(action: SetStateAction<T>, prev: T): T;
-
-/**
- *  Finds all values matching the search values by first mapping the values to a string array and then checking each entry for matches.
- *  Returns the list of all matches.
- *
- *  @param search The list of search strings e.g. `[name, type]`
- *
- *  @param objects The list of objects to be searched in
- *
- *  @param mapping The mapping of objects to the string properties they fulfil
- *
- *  @return The list of objects that match all search strings
- */
-declare const MultiSubjectSearchWithMapping: <T>(search: string[], objects: T[], mapping: (value: T) => (string[] | undefined)) => T[];
-/**
- *  Finds all values matching the search value by first mapping the values to a string array and then checking each entry for matches.
- *  Returns the list of all matches.
- *
- *  @param search The search string e.g `name`
- *
- *  @param objects The list of objects to be searched in
- *
- *  @param mapping The mapping of objects to the string properties they fulfil, if undefined it is always fulfilled
- *
- *  @return The list of objects that match the search string
- */
-declare const MultiSearchWithMapping: <T>(search: string, objects: T[], mapping: (value: T) => (string[] | undefined)) => T[];
-/**
- *  Finds all values matching the search value by first mapping the values to a string and returns the list of all matches.
- *
- *  @param search The search string e.g `name`
- *
- *  @param objects The list of objects to be searched in
- *
- *  @param mapping The mapping of objects to a string that is compared to the search
- *
- *  @return The list of objects that match the search string
- */
-declare const SimpleSearchWithMapping: <T>(search: string, objects: T[], mapping: (value: T) => string) => T[];
-/**
- *  Finds all values matching the search value and returns the list of all matches.
- *
- *  @param search The search string e.g `name`
- *
- *  @param objects The list of objects to be searched in
- *
- *  @return The list of objects that match the search string
- */
-declare const SimpleSearch: (search: string, objects: string[]) => string[];
-
-declare const writeToClipboard: (text: string) => Promise<void>;
-
 type TimePickerMinuteIncrement = '1min' | '5min' | '10min' | '15min' | '30min';
 type TimePickerSecondIncrement = '1s' | '5s' | '10s' | '15s' | '30s';
 type TimePickerMillisecondIncrement = '1ms' | '5ms' | '10ms' | '25ms' | '50ms' | '100ms' | '250ms' | '500ms';
@@ -2538,7 +2681,8 @@ type DatePropertyProps = PropertyField<Date> & {
  */
 declare const DateProperty: ({ value, onValueChange, onEditComplete, readOnly, type, ...baseProps }: DatePropertyProps) => react_jsx_runtime.JSX.Element;
 
-type MultiSelectPropertyProps = PropertyField<string[]> & PropsWithChildren;
+interface MultiSelectPropertyProps extends PropertyField<string[]>, PropsWithChildren {
+}
 /**
  * An Input for MultiSelect properties
  */
@@ -2552,7 +2696,8 @@ type NumberPropertyProps = PropertyField<number> & {
  */
 declare const NumberProperty: ({ value, onValueChange, onEditComplete, onValueClear, readOnly, suffix, ...baseProps }: NumberPropertyProps) => react_jsx_runtime.JSX.Element;
 
-type SingleSelectPropertyProps = PropertyField<string> & PropsWithChildren;
+interface SingleSelectPropertyProps extends PropertyField<string>, PropsWithChildren {
+}
 /**
  * An Input for SingleSelect properties
  */
@@ -2561,52 +2706,8 @@ declare const SingleSelectProperty: ({ children, value, onValueChange, onEditCom
 type TextPropertyProps = PropertyField<string>;
 /**
  * An Input for Text properties
- */
-declare const TextProperty: ({ value, readOnly, onValueChange, onEditComplete, ...baseProps }: TextPropertyProps) => react_jsx_runtime.JSX.Element;
-
-type MultiSelectProps = MultiSelectRootProps & {
-    contentPanelProps?: MultiSelectContentProps;
-    buttonProps?: MultiSelectButtonProps;
-};
-declare const MultiSelect: react.ForwardRefExoticComponent<Partial<FormFieldInteractionStates> & {
-    children?: react.ReactNode | undefined;
-} & {
-    id?: string;
-    initialIsOpen?: boolean;
-    iconAppearance?: SelectIconAppearance;
-    onClose?: () => void;
-} & Partial<FormFieldDataHandling<string[]>> & {
-    initialValue?: string[];
-} & {
-    contentPanelProps?: MultiSelectContentProps;
-    buttonProps?: MultiSelectButtonProps;
-} & react.RefAttributes<HTMLButtonElement>>;
-
-type MultiSelectChipDisplayButtonProps = HTMLAttributes<HTMLDivElement> & {
-    disabled?: boolean;
-    placeholder?: ReactNode;
-};
-declare const MultiSelectChipDisplayButton: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
-    disabled?: boolean;
-    placeholder?: ReactNode;
-} & react.RefAttributes<HTMLDivElement>>;
-type MultiSelectChipDisplayProps = MultiSelectRootProps & {
-    contentPanelProps?: MultiSelectContentProps;
-    chipDisplayProps?: MultiSelectChipDisplayButtonProps;
-};
-declare const MultiSelectChipDisplay: react.ForwardRefExoticComponent<Partial<FormFieldInteractionStates> & {
-    children?: ReactNode | undefined;
-} & {
-    id?: string;
-    initialIsOpen?: boolean;
-    iconAppearance?: SelectIconAppearance;
-    onClose?: () => void;
-} & Partial<FormFieldDataHandling<string[]>> & {
-    initialValue?: string[];
-} & {
-    contentPanelProps?: MultiSelectContentProps;
-    chipDisplayProps?: MultiSelectChipDisplayButtonProps;
-} & react.RefAttributes<HTMLDivElement>>;
+ */
+declare const TextProperty: ({ value, readOnly, onValueChange, onEditComplete, ...baseProps }: TextPropertyProps) => react_jsx_runtime.JSX.Element;
 
 interface FocusTrapProps extends PropsWithChildren, UseFocusTrapProps {
 }
@@ -2618,11 +2719,30 @@ interface FocusTrapWrapperProps extends HTMLAttributes<HTMLDivElement>, Omit<Foc
  */
 declare const FocusTrapWrapper: react.ForwardRefExoticComponent<FocusTrapWrapperProps & react.RefAttributes<HTMLDivElement>>;
 
+interface PolymorphicSlotProps extends SlotProps {
+    asChild?: boolean;
+    defaultComponent?: ElementType;
+}
+declare const PolymorphicSlot: react.ForwardRefExoticComponent<PolymorphicSlotProps & react.RefAttributes<HTMLElement>>;
+
 interface PortalProps extends PropsWithChildren {
     container?: HTMLElement;
 }
 declare const Portal: ({ children, container }: PortalProps) => react.ReactPortal;
 
+type BagFunction<B, V = ReactNode> = (bag: B) => V;
+type BagFunctionOrValue<B, V> = BagFunction<B, V> | V;
+type BagFunctionOrNode<B> = BagFunction<B> | ReactNode;
+type PropsWithBagFunction<B, P = unknown> = P & {
+    children?: BagFunction<B>;
+};
+type PropsWithBagFunctionOrChildren<B, P = unknown> = P & {
+    children?: BagFunctionOrNode<B>;
+};
+declare const BagFunctionUtil: {
+    resolve: <B, V = ReactNode>(bagFunctionOrValue: BagFunctionOrValue<B, V>, bag: B) => V;
+};
+
 type TransitionBag = {
     isOpen: boolean;
     isTransitioning: boolean;
@@ -2707,6 +2827,22 @@ declare function useEventCallbackStabilizer<T extends (...args: any[]) => any>(c
 type ElementHandle = Record<string, HTMLElement | null>;
 declare function useHandleRefs<T extends ElementHandle>(handleRef: RefObject<T>): RefObject<HTMLElement | null>[];
 
+interface ListNavigationReturn {
+    highlightedId: string | null;
+    highlight: (id: string) => void;
+    first: () => void;
+    last: () => void;
+    next: () => void;
+    previous: () => void;
+}
+interface ListNavigationOptions {
+    options: ReadonlyArray<string>;
+    value?: string | null;
+    onValueChange?: (highlightedId: string | null) => void;
+    initialValue?: string | null;
+}
+declare function useListNavigation({ options, value, onValueChange, initialValue, }: ListNavigationOptions): ListNavigationReturn;
+
 type OptionsResolved = {
     type?: 'info' | 'error' | 'warning';
 };
@@ -2715,6 +2851,25 @@ declare const useLogOnce: (message: string, condition: boolean, options?: Option
 
 declare function useLogUnstableDependencies<T extends Record<string, unknown>>(name: string, value: T): void;
 
+interface UseMultiSelectionOption {
+    id: string;
+    disabled?: boolean;
+}
+interface UseMultiSelectionOptions {
+    options: ReadonlyArray<UseMultiSelectionOption>;
+    value?: ReadonlyArray<string>;
+    onSelectionChange?: (selection: ReadonlyArray<string>) => void;
+    initialSelection?: ReadonlyArray<string>;
+    isControlled?: boolean;
+}
+interface UseMultiSelectionReturn {
+    selection: ReadonlyArray<string>;
+    setSelection: (selection: ReadonlyArray<string>) => void;
+    toggleSelection: (id: string) => void;
+    isSelected: (id: string) => boolean;
+}
+declare function useMultiSelection({ options: optionsList, value, onSelectionChange, initialSelection, isControlled, }: UseMultiSelectionOptions): UseMultiSelectionReturn;
+
 type OverlayItem = {
     id: string;
     tags?: string[];
@@ -2792,24 +2947,38 @@ type UseScrollObserverProps = {
 };
 declare function useScrollObserver({ observedElementRef, onScroll, isActive }: UseScrollObserverProps): void;
 
-type UseSearchProps<T> = {
-    list: T[];
-    searchMapping: (item: T) => string[];
-    initialSearch?: string;
-    additionalSearchTags?: string[];
-    isSearchInstant?: boolean;
-    sortingFunction?: (a: T, b: T) => number;
-    filter?: (item: T) => boolean;
+interface UseSearchOptions<T> {
+    items: ReadonlyArray<T>;
+    searchQuery: string;
+    toTags?: (value: T) => string[];
+}
+interface UseSearchReturn<T> {
+    searchResult: ReadonlyArray<T>;
+}
+declare function useSearch<T>({ items, searchQuery, toTags, }: UseSearchOptions<T>): UseSearchReturn<T>;
+
+interface SelectionOption {
+    id: string;
     disabled?: boolean;
-};
-declare const useSearch: <T>({ list, initialSearch, searchMapping, additionalSearchTags, isSearchInstant, sortingFunction, filter, disabled, }: UseSearchProps<T>) => {
-    result: T[];
-    hasResult: boolean;
-    allItems: T[];
-    updateSearch: (newSearch?: string) => void;
-    search: string;
-    setSearch: react.Dispatch<react.SetStateAction<string>>;
-};
+}
+interface UseSingleSelectionOptions {
+    options: ReadonlyArray<SelectionOption>;
+    selection?: string | null;
+    onSelectionChange?: (selection: string | null) => void;
+    initialSelection?: string | null;
+    isLooping?: boolean;
+}
+interface SingleSelectionReturn {
+    selection: string | null;
+    selectedIndex: number | null;
+    selectByIndex: (index: number) => void;
+    selectValue: (value: string | null) => void;
+    selectFirst: () => void;
+    selectLast: () => void;
+    selectNext: () => void;
+    selectPrevious: () => void;
+}
+declare function useSingleSelection({ options: optionsList, selection: controlledSelection, onSelectionChange, initialSelection, isLooping, }: UseSingleSelectionOptions): SingleSelectionReturn;
 
 interface UseStorageProps<T> {
     key: string;
@@ -2840,6 +3009,18 @@ type UseTransitionStateProps = {
 };
 declare const useTransitionState: ({ isOpen, initialState, ref, timeout: initialTimeout, }: UseTransitionStateProps) => UseTransitionStateResult;
 
+interface UseTypeAheadSearchOptions<T> {
+    options: ReadonlyArray<T>;
+    resetTimer: number;
+    toString?: (value: T) => string;
+    onResultChange: (value: T | null) => void;
+}
+interface UseTypeAheadSearchReturn {
+    addToTypeAhead: (str: string) => void;
+    reset: () => void;
+}
+declare function useTypeAheadSearch<T>({ options, resetTimer, toString: toStringProp, onResultChange, }: UseTypeAheadSearchOptions<T>): UseTypeAheadSearchReturn;
+
 interface UseUpdatingDateStringProps {
     date: Date;
     absoluteFormat?: DateTimeFormat;
@@ -2891,4 +3072,222 @@ declare const LocalizationUtil: {
     languagesLocalNames: Record<"de-DE" | "en-US", string>;
 };
 
-export { ASTNodeInterpreter, type ASTNodeInterpreterProps, AnchoredFloatingContainer, type AnchoredFloatingContainerProps, ArrayUtil, AutoColumnOrderFeature, Avatar, AvatarGroup, type AvatarGroupProps, type AvatarProps, type AvatarSize, type BackgroundOverlayProps, type BagFunction, type BagFunctionOrNode, type BagFunctionOrValue, BagFunctionUtil, BooleanFilter, type BooleanFilterParameter, type BooleanFilterProps, type BooleanFilterValue, BreadCrumbGroup, BreadCrumbLink, type BreadCrumbLinkProps, type BreadCrumbProps, BreadCrumbs, Button, type ButtonColor, type ButtonProps, ButtonUtil, Carousel, type CarouselProps, CarouselSlide, type CarouselSlideProps, Checkbox, CheckboxProperty, type CheckboxPropertyProps, type CheckboxProps, Chip, type ChipColor, ChipList, type ChipListProps, type ChipProps, ChipUtil, type ColumnSizeCalculatoProps, ColumnSizeUtil, ColumnSizingWithTargetFeature, ConfirmDialog, type ConfirmDialogProps, type ConfirmDialogType, type ControlledStateProps, CopyToClipboardWrapper, type CopyToClipboardWrapperProps, type Crumb, DateFilter, type DateFilterParameter, type DateFilterProps, type DateFilterValue, DatePicker, type DatePickerProps, DateProperty, type DatePropertyProps, DateTimeFormat, DateTimeInput, type DateTimeInputProps, DateTimePicker, DateTimePickerDialog, type DateTimePickerDialogProps, type DateTimePickerProps, type DateTimePrecision, DateUtils, DatetimeFilter, type DatetimeFilterParameter, type DatetimeFilterProps, type DatetimeFilterValue, DayPicker, type DayPickerProps, type DeepPartial, Dialog, DialogContext, type DialogContextType, type DialogOpenerPassingProps, DialogOpenerWrapper, type DialogOpenerWrapperBag, type DialogOpenerWrapperProps, type DialogPosition, type DialogProps, DialogRoot, type DialogRootProps, type Direction, DiscardChangesDialog, DividerInserter, type DividerInserterProps, Drawer, type DrawerAligment, DrawerCloseButton, type DrawerCloseButtonProps, DrawerContent, type DrawerContentProps, DrawerContext, type DrawerContextType, type DrawerProps, DrawerRoot, type DrawerRootProps, Duration, type DurationJSON, type EaseFunction, EaseFunctions, type EditCompleteOptions, type EditCompleteOptionsResolved, type ElementHandle, ErrorComponent, type ErrorComponentProps, type Exact, Expandable, ExpandableContent, type ExpandableContentProps, ExpandableHeader, type ExpandableHeaderProps, type ExpandableProps, ExpandableRoot, type ExpandableRootProps, ExpansionIcon, type ExpansionIconProps, type FAQItem, FAQSection, type FAQSectionProps, FillerCell, type FillerCellProps, type FloatingElementAlignment, FocusTrap, type FocusTrapProps, FocusTrapWrapper, type FocusTrapWrapperProps, FormContext, type FormContextType, type FormEvent, type FormEventListener, FormField, type FormFieldAriaAttributes, type FormFieldBag, type FormFieldDataHandling, type FormFieldFocusableElementProps, type FormFieldInteractionStates, FormFieldLayout, type FormFieldLayoutBag, type FormFieldLayoutIds, type FormFieldLayoutProps, type FormFieldProps, type FormFieldResult, FormObserver, FormObserverKey, type FormObserverKeyProps, type FormObserverKeyResult, type FormObserverProps, type FormObserverResult, FormProvider, type FormProviderProps, FormStore, type FormStoreProps, type FormValidationBehaviour, type FormValidator, type FormValue, GenericFilter, type GenericFilterParameter, type GenericFilterProps, type GenericFilterValue, HelpwaveBadge, type HelpwaveBadgeProps, HelpwaveLogo, type HelpwaveProps, type HighlightStartPositionBehavior, type HightideConfig, HightideConfigContext, HightideConfigProvider, type HightideConfigProviderProps, HightideProvider, type HightideTranslationEntries, type HightideTranslationLocales, IconButton, IconButtonBase, type IconButtonBaseProps, type IconButtonProps, InfiniteScroll, type InfiniteScrollProps, Input, InputDialog, type InputModalProps, type InputProps, InsideLabelInput, LanguageDialog, LanguageSelect, ListBox, ListBoxItem, type ListBoxItemProps, ListBoxMultiple, type ListBoxMultipleProps, ListBoxPrimitive, type ListBoxPrimitiveProps, type ListBoxProps, LoadingAndErrorComponent, type LoadingAndErrorComponentProps, LoadingAnimation, type LoadingAnimationProps, type LoadingComponentProps, LoadingContainer, LocaleContext, type LocaleContextValue, LocaleProvider, type LocaleProviderProps, type LocalizationConfig, LocalizationUtil, LoopingArrayCalculator, MarkdownInterpreter, type MarkdownInterpreterProps, MathUtil, Menu, type MenuBag, MenuItem, type MenuItemProps, type MenuProps, type Month, MultiSearchWithMapping, MultiSelect, MultiSelectButton, type MultiSelectButtonProps, MultiSelectChipDisplay, MultiSelectChipDisplayButton, type MultiSelectChipDisplayProps, MultiSelectContent, type MultiSelectContentProps, MultiSelectOption, type MultiSelectOptionProps, MultiSelectProperty, type MultiSelectPropertyProps, type MultiSelectProps, MultiSelectRoot, type MultiSelectRootProps, MultiSubjectSearchWithMapping, Navigation, NavigationItemList, type NavigationItemListProps, type NavigationItemType, type NavigationProps, NumberFilter, type NumberFilterParameter, type NumberFilterProps, type NumberFilterValue, NumberProperty, type NumberPropertyProps, OperatorLabel, type OperatorLabelProps, type OverlayItem, OverlayRegistry, Pagination, type PaginationProps, PopUp, PopUpContext, type PopUpContextType, PopUpOpener, type PopUpOpenerBag, type PopUpOpenerProps, type PopUpProps, PopUpRoot, type PopUpRootProps, Portal, type PortalProps, ProgressIndicator, type ProgressIndicatorProps, PromiseUtils, PropertyBase, type PropertyBaseProps, type PropertyField, PropsUtil, type PropsWithBagFunction, type PropsWithBagFunctionOrChildren, type Range, type RangeOptions, type ResolvedTheme, ScrollPicker, type ScrollPickerProps, SearchBar, type SearchBarProps, Select, SelectButton, type SelectButtonProps, SelectContent, type SelectContentProps, SelectContext, type SelectIconAppearance, SelectOption, type SelectOptionProps, type SelectProps, SelectRoot, type SelectRootProps, type SharedSelectRootProps, SimpleSearch, SimpleSearchWithMapping, type SingleOrArray, SingleSelectProperty, type SingleSelectPropertyProps, StepperBar, type StepperBarProps, type StepperState, StorageListener, type StorageSubscriber, type SuperSet, Switch, type SwitchProps, type TabContextType, type TabInfo, TabList, TabPanel, TabSwitcher, type TabSwitcherProps, TabView, Table, TableBody, type TableBooleanFilter, TableCell, type TableCellProps, TableColumn, TableColumnDefinitionContext, type TableColumnDefinitionContextType, type TableColumnProps, TableColumnSwitcher, TableColumnSwitcherPopUp, type TableColumnSwitcherPopUpProps, type TableColumnSwitcherProps, TableContainerContext, type TableContainerContextType, type TableDateFilter, type TableDatetimeFilter, TableDisplay, type TableDisplayProps, TableFilter, type TableFilterBaseProps, TableFilterButton, type TableFilterButtonProps, type TableFilterCategory, TableFilterContent, type TableFilterContentProps, TableFilterOperator, type TableFilterType, type TableFilterValue, type TableGenericFilter, TableHeader, type TableHeaderProps, type TableNumberFilter, TablePageSizeSelect, type TablePageSizeSelectProps, TablePagination, TablePaginationMenu, type TablePaginationMenuProps, type TablePaginationProps, type TableProps, TableProvider, type TableProviderProps, TableSortButton, type TableSortButtonProps, TableStateContext, type TableStateContextType, TableStateWithoutSizingContext, type TableStateWithoutSizingContextType, type TableTagsFilter, type TableTagsSingleFilter, type TableTextFilter, TableWithSelection, type TableWithSelectionProps, TableWithSelectionProvider, type TableWithSelectionProviderProps, TagIcon, type TagProps, TagsFilter, type TagsFilterParameter, type TagsFilterProps, type TagsFilterValue, TagsSingleFilter, type TagsSingleFilterParameter, type TagsSingleFilterProps, type TagsSingleFilterValue, TextFilter, type TextFilterParameter, type TextFilterProps, type TextFilterValue, TextImage, type TextImageProps, TextProperty, type TextPropertyProps, Textarea, type TextareaProps, TextareaWithHeadline, type TextareaWithHeadlineProps, type ThemeConfig, ThemeContext, ThemeDialog, type ThemeDialogProps, ThemeIcon, type ThemeIconProps, ThemeProvider, type ThemeProviderProps, ThemeSelect, type ThemeSelectProps, type ThemeType, ThemeUtil, TimeDisplay, TimePicker, type TimePickerMillisecondIncrement, type TimePickerMinuteIncrement, type TimePickerProps, type TimePickerSecondIncrement, ToggleableInput, Tooltip, type TooltipConfig, TooltipContext, type TooltipContextType, TooltipDisplay, type TooltipDisplayProps, type TooltipProps, TooltipRoot, type TooltipRootProps, TooltipTrigger, type TooltipTriggerBag, type TooltipTriggerContextValue, type TooltipTriggerProps, Transition, type TransitionState, type TransitionWrapperProps, type UnBoundedRange, type UseAnchoredPositionOptions, type UseAnchoredPostitionProps, type UseCreateFormProps, type UseCreateFormResult, type UseDelayOptions, type UseDelayOptionsResolved, type UseFocusTrapProps, type UseFormFieldOptions, type UseFormFieldParameter, type UseFormObserverKeyProps, type UseFormObserverProps, type UseOutsideClickHandlers, type UseOutsideClickOptions, type UseOutsideClickProps, type UseOverlayRegistryProps, type UseOverlayRegistryResult, type UsePresenceRefProps, type UseResizeObserverProps, type UseSearchProps, type UseUpdatingDateStringProps, UseValidators, type UserFormFieldProps, type ValidatorError, type ValidatorResult, VerticalDivider, type VerticalDividerProps, Visibility, type VisibilityProps, type WeekDay, YearMonthPicker, type YearMonthPickerProps, builder, closestMatch, createLoopingList, createLoopingListWithIndex, equalSizeGroups, filterBoolean, filterDate, filterDatetime, filterGeneric, filterNumber, filterTags, filterTagsSingle, filterText, getNeighbours, hightideTranslation, hightideTranslationLocales, isTableFilterCategory, match, mergeProps, noop, range, resolveSetState, toSizeVars, useAnchoredPosition, useControlledState, useCreateForm, useDelay, useDialogContext, useDrawerContext, useEventCallbackStabilizer, useFocusGuards, useFocusManagement, useFocusOnceVisible, useFocusTrap, useForm, useFormField, useFormObserver, useFormObserverKey, useHandleRefs, useHightideConfig, useHightideTranslation, useICUTranslation, useIsMounted, useLanguage, useLocale, useLogOnce, useLogUnstableDependencies, useOutsideClick, useOverlayRegistry, useOverwritableState, usePopUpContext, usePresenceRef, useRerender, useResizeObserver, useScrollObserver, useSearch, useSelectContext, useStorage, useTabContext, useTableColumnDefinitionContext, useTableContainerContext, useTableStateContext, useTableStateWithoutSizingContext, useTheme, useTooltip, useTransitionState, useTranslatedValidators, useUpdatingDateString, useWindowResizeObserver, validateEmail, writeToClipboard };
+type StorageSubscriber = (raw: string | null) => void;
+declare class StorageListener {
+    private static instance;
+    private localSubscriptions;
+    private sessionSubscriptions;
+    private initialized;
+    private constructor();
+    static getInstance(): StorageListener;
+    subscribe(storage: Storage, key: string, cb: StorageSubscriber): () => void;
+    private init;
+    private handleEvent;
+    private getRegistry;
+}
+
+declare const equalSizeGroups: <T>(array: T[], groupSize: number) => T[][];
+type RangeOptions = {
+    /**  Whether the range can be defined empty via end < start without a warning */
+    allowEmptyRange: boolean;
+    stepSize: number;
+    exclusiveStart: boolean;
+    exclusiveEnd: boolean;
+};
+/**
+ * @param endOrRange The end value or a range [start, end], end is exclusive
+ * @param options the options for defining the range
+ */
+declare const range: (endOrRange: number | [number, number], options?: Partial<RangeOptions>) => number[];
+/** Finds the closest match
+ * @param list The list of all possible matches
+ * @param firstCloser Return whether item1 is closer than item2
+ */
+declare const closestMatch: <T>(list: T[], firstCloser: (item1: T, item2: T) => boolean) => T;
+/**
+ * returns the item in middle of a list and its neighbours before and after
+ * e.g. [1,2,3,4,5,6] for item = 1 would return [5,6,1,2,3]
+ */
+declare const getNeighbours: <T>(list: T[], item: T, neighbourDistance?: number) => T[];
+declare const createLoopingListWithIndex: <T>(list: T[], startIndex?: number, length?: number, forwards?: boolean) => [number, T][];
+declare const createLoopingList: <T>(list: T[], startIndex?: number, length?: number, forwards?: boolean) => T[];
+declare function resolveSingleOrArray<T>(value: T | T[]): T[];
+declare const ArrayUtil: {
+    unique: <T>(list: T[]) => T[];
+    difference: <T>(list: T[], removeList: T[]) => T[];
+    moveItems: <T>(list: T[], move?: number) => any[];
+    resolveSingleOrArray: typeof resolveSingleOrArray;
+};
+
+/**
+ * A simple function that implements the builder pattern
+ * @param value The value to update which gets return with the same reference
+ * @param update The updates to apply on the object
+ */
+declare const builder: <T>(value: T, update: (value: T) => void) => T;
+
+declare function compareDocumentPosition(a: Node | null | undefined, b: Node | null | undefined): 0 | 1 | -1;
+declare const DOMUtils: {
+    compareDocumentPosition: typeof compareDocumentPosition;
+};
+
+type EaseFunction = (t: number) => number;
+declare class EaseFunctions {
+    static cubicBezierGeneric(x1: number, y1: number, x2: number, y2: number): {
+        x: EaseFunction;
+        y: EaseFunction;
+    };
+    static cubicBezier(x1: number, y1: number, x2: number, y2: number): EaseFunction;
+    static easeInEaseOut(t: number): number;
+}
+
+declare const validateEmail: (email: string) => boolean;
+
+/**
+ *  1 is forwards
+ *
+ * -1 is backwards
+ */
+type Direction = 1 | -1;
+declare class LoopingArrayCalculator {
+    length: number;
+    isLooping: boolean;
+    allowedOverScroll: number;
+    constructor(length: number, isLooping?: boolean, allowedOverScroll?: number);
+    getCorrectedPosition(position: number): number;
+    static withoutOffset(position: number): number;
+    static getOffset(position: number): number;
+    /**
+     * @return absolute distance forwards or Infinity when the target cannot be reached (only possible when not isLooping)
+     */
+    getDistanceDirectional(position: number, target: number, direction: Direction): number;
+    getDistanceForward(position: number, target: number): number;
+    getDistanceBackward(position: number, target: number): number;
+    getDistance(position: number, target: number): number;
+    getBestDirection(position: number, target: number): Direction;
+}
+
+declare const match: <K extends string | number | symbol, V>(key: K, values: Record<K, V>) => Record<K, V>[K];
+
+type Range = [number, number];
+type UnBoundedRange = [undefined | number, undefined | number];
+declare function clamp(value: number, min: number, max: number): number;
+declare function clamp(value: number, range?: [number, number]): number;
+declare const MathUtil: {
+    clamp: typeof clamp;
+};
+
+declare const noop: () => any;
+
+declare function sleep(ms: number): Promise<void>;
+declare function delayed<T>(value: T, ms: number): Promise<T>;
+declare const PromiseUtils: {
+    sleep: typeof sleep;
+    delayed: typeof delayed;
+};
+
+declare function bool(isActive: boolean): string | undefined;
+type InteractionStateDataAttributes = {
+    'data-disabled': string | undefined;
+    'data-invalid': string | undefined;
+    'data-readonly': string | undefined;
+    'data-required': string | undefined;
+};
+declare function interactionStatesData(interactionStates: Partial<FormFieldInteractionStates>): Partial<InteractionStateDataAttributes>;
+type MouseEventExtenderProps<T> = {
+    fromProps?: react__default.MouseEventHandler<T>;
+    extensions: SingleOrArray<react__default.MouseEventHandler<T>>;
+};
+declare function mouseEventExtender<T>({ fromProps, extensions }: MouseEventExtenderProps<T>): react__default.MouseEventHandler<T>;
+type KeyoardEventExtenderProps<T> = {
+    fromProps: react__default.KeyboardEventHandler<T>;
+    extensions: SingleOrArray<react__default.KeyboardEventHandler<T>>;
+};
+declare function keyboardEventExtender<T>({ fromProps, extensions, }: KeyoardEventExtenderProps<T>): react__default.KeyboardEventHandler<T>;
+declare function click<T>(onClick: () => void): {
+    onClick: () => void;
+    onKeyDown: react__default.KeyboardEventHandler<T>;
+};
+declare function close<T>(onClose?: () => void): react__default.KeyboardEventHandler<T>;
+type NavigateType<T> = {
+    left?: (event: react__default.KeyboardEvent<T>) => void;
+    right?: (event: react__default.KeyboardEvent<T>) => void;
+    up?: (event: react__default.KeyboardEvent<T>) => void;
+    down?: (event: react__default.KeyboardEvent<T>) => void;
+};
+declare function navigate<T>({ left, right, up, down, }: NavigateType<T>): react__default.KeyboardEventHandler<T>;
+declare function mergeProps<T extends object, U extends Partial<T>>(slotProps: T, childProps: U): T & U;
+type InteractionStateARIAAttributes = Pick<HTMLAttributes<HTMLDivElement>, 'aria-disabled' | 'aria-invalid' | 'aria-readonly' | 'aria-required'>;
+declare function interactionStatesAria(interactionStates: Partial<FormFieldInteractionStates>, props?: Partial<InteractionStateARIAAttributes>): Partial<InteractionStateARIAAttributes>;
+declare const PropsUtil: {
+    extender: {
+        mouseEvent: typeof mouseEventExtender;
+        keyboardEvent: typeof keyboardEventExtender;
+    };
+    dataAttributes: {
+        bool: typeof bool;
+        interactionStates: typeof interactionStatesData;
+    };
+    aria: {
+        close: typeof close;
+        click: typeof click;
+        navigate: typeof navigate;
+        interactionStates: typeof interactionStatesAria;
+    };
+    mergeProps: typeof mergeProps;
+};
+
+declare function resolveSetState<T>(action: SetStateAction<T>, prev: T): T;
+
+/**
+ *  Finds all values matching the search values by first mapping the values to a string array and then checking each entry for matches.
+ *  Returns the list of all matches.
+ *
+ *  @param search The list of search strings e.g. `[name, type]`
+ *
+ *  @param objects The list of objects to be searched in
+ *
+ *  @param mapping The mapping of objects to the string properties they fulfil
+ *
+ *  @return The list of objects that match all search strings
+ */
+declare const MultiSubjectSearchWithMapping: <T>(search: string[], objects: T[], mapping: (value: T) => (string[] | undefined)) => T[];
+/**
+ *  Finds all values matching the search value by first mapping the values to a string array and then checking each entry for matches.
+ *  Returns the list of all matches.
+ *
+ *  @param search The search string e.g `name`
+ *
+ *  @param objects The list of objects to be searched in
+ *
+ *  @param mapping The mapping of objects to the string properties they fulfil, if undefined it is always fulfilled
+ *
+ *  @return The list of objects that match the search string
+ */
+declare const MultiSearchWithMapping: <T>(search: string, objects: T[], mapping: (value: T) => (string[] | undefined)) => T[];
+/**
+ *  Finds all values matching the search value by first mapping the values to a string and returns the list of all matches.
+ *
+ *  @param search The search string e.g `name`
+ *
+ *  @param objects The list of objects to be searched in
+ *
+ *  @param mapping The mapping of objects to a string that is compared to the search
+ *
+ *  @return The list of objects that match the search string
+ */
+declare const SimpleSearchWithMapping: <T>(search: string, objects: T[], mapping: (value: T) => string) => T[];
+/**
+ *  Finds all values matching the search value and returns the list of all matches.
+ *
+ *  @param search The search string e.g `name`
+ *
+ *  @param objects The list of objects to be searched in
+ *
+ *  @return The list of objects that match the search string
+ */
+declare const SimpleSearch: (search: string, objects: string[]) => string[];
+
+declare const writeToClipboard: (text: string) => Promise<void>;
+
+export { ASTNodeInterpreter, type ASTNodeInterpreterProps, AnchoredFloatingContainer, type AnchoredFloatingContainerProps, ArrayUtil, AutoColumnOrderFeature, Avatar, AvatarGroup, type AvatarGroupProps, type AvatarProps, type AvatarSize, type BackgroundOverlayProps, type BagFunction, type BagFunctionOrNode, type BagFunctionOrValue, BagFunctionUtil, BooleanFilterPopUp, BreadCrumbGroup, BreadCrumbLink, type BreadCrumbLinkProps, type BreadCrumbProps, BreadCrumbs, Button, type ButtonColor, type ButtonProps, ButtonUtil, Carousel, type CarouselProps, CarouselSlide, type CarouselSlideProps, Checkbox, CheckboxProperty, type CheckboxPropertyProps, type CheckboxProps, Chip, type ChipColor, ChipList, type ChipListProps, type ChipProps, ChipUtil, type ColumnSizeCalculatoProps, ColumnSizeUtil, ColumnSizingWithTargetFeature, Combobox, ComboboxContext, type ComboboxContextActions, type ComboboxContextComputedState, type ComboboxContextConfig, type ComboboxContextIds, type ComboboxContextInternalState, type ComboboxContextLayout, type ComboboxContextSearch, type ComboboxContextType, ComboboxInput, type ComboboxInputProps, ComboboxList, type ComboboxListProps, ComboboxOption, type ComboboxOptionProps, type ComboboxOptionType, type ComboboxProps, ComboboxRoot, type ComboboxRootProps, ConfirmDialog, type ConfirmDialogProps, type ConfirmDialogType, type ControlledStateProps, CopyToClipboardWrapper, type CopyToClipboardWrapperProps, type Crumb, DOMUtils, type DataType, type DataTypeFilterPopUpProps, DataTypeUtils, type DataValue, DateFilterPopUp, DatePicker, type DatePickerProps, DateProperty, type DatePropertyProps, DateTimeFormat, DateTimeInput, type DateTimeInputProps, DateTimePicker, DateTimePickerDialog, type DateTimePickerDialogProps, type DateTimePickerProps, type DateTimePrecision, DateUtils, DatetimeFilterPopUp, DayPicker, type DayPickerProps, type DeepPartial, Dialog, DialogContext, type DialogContextType, type DialogOpenerPassingProps, DialogOpenerWrapper, type DialogOpenerWrapperBag, type DialogOpenerWrapperProps, type DialogPosition, type DialogProps, DialogRoot, type DialogRootProps, type Direction, DiscardChangesDialog, DividerInserter, type DividerInserterProps, Drawer, type DrawerAligment, DrawerCloseButton, type DrawerCloseButtonProps, DrawerContent, type DrawerContentProps, DrawerContext, type DrawerContextType, type DrawerProps, DrawerRoot, type DrawerRootProps, Duration, type DurationJSON, type EaseFunction, EaseFunctions, type EditCompleteOptions, type EditCompleteOptionsResolved, type ElementHandle, ErrorComponent, type ErrorComponentProps, type Exact, Expandable, ExpandableContent, type ExpandableContentProps, ExpandableHeader, type ExpandableHeaderProps, type ExpandableProps, ExpandableRoot, type ExpandableRootProps, ExpansionIcon, type ExpansionIconProps, type FAQItem, FAQSection, type FAQSectionProps, FillerCell, type FillerCellProps, FilterBasePopUp, FilterFunctions, FilterList, type FilterListItem, type FilterListPopUpBuilderProps, type FilterListProps, type FilterOperator, type FilterOperatorBoolean, type FilterOperatorDate, type FilterOperatorDatetime, FilterOperatorLabel, type FilterOperatorLabelProps, type FilterOperatorNumber, type FilterOperatorTags, type FilterOperatorTagsSingle, type FilterOperatorText, type FilterOperatorUnknownType, FilterOperatorUtils, type FilterParameter, FilterPopUp, type FilterPopUpBaseProps, type FilterPopUpProps, type FilterValue, type FilterValueTranslationOptions, FilterValueUtils, type FloatingElementAlignment, FocusTrap, type FocusTrapProps, FocusTrapWrapper, type FocusTrapWrapperProps, FormContext, type FormContextType, type FormEvent, type FormEventListener, FormField, type FormFieldAriaAttributes, type FormFieldBag, type FormFieldDataHandling, type FormFieldFocusableElementProps, type FormFieldInteractionStates, FormFieldLayout, type FormFieldLayoutBag, type FormFieldLayoutIds, type FormFieldLayoutProps, type FormFieldProps, type FormFieldResult, FormObserver, FormObserverKey, type FormObserverKeyProps, type FormObserverKeyResult, type FormObserverProps, type FormObserverResult, FormProvider, type FormProviderProps, FormStore, type FormStoreProps, type FormValidationBehaviour, type FormValidator, type FormValue, GenericFilterPopUp, HelpwaveBadge, type HelpwaveBadgeProps, HelpwaveLogo, type HelpwaveProps, type HightideConfig, HightideConfigContext, HightideConfigProvider, type HightideConfigProviderProps, HightideProvider, type HightideTranslationEntries, type HightideTranslationLocales, IconButton, IconButtonBase, type IconButtonBaseProps, type IconButtonProps, type IdentifierFilterValue, InfiniteScroll, type InfiniteScrollProps, Input, InputDialog, type InputModalProps, type InputProps, InsideLabelInput, LanguageDialog, LanguageSelect, type ListNavigationOptions, type ListNavigationReturn, LoadingAndErrorComponent, type LoadingAndErrorComponentProps, LoadingAnimation, type LoadingAnimationProps, type LoadingComponentProps, LoadingContainer, LocaleContext, type LocaleContextValue, LocaleProvider, type LocaleProviderProps, type LocalizationConfig, LocalizationUtil, LoopingArrayCalculator, MarkdownInterpreter, type MarkdownInterpreterProps, MathUtil, Menu, type MenuBag, MenuItem, type MenuItemProps, type MenuProps, type Month, MultiSearchWithMapping, MultiSelect, MultiSelectButton, type MultiSelectButtonProps, MultiSelectChipDisplay, MultiSelectChipDisplayButton, type MultiSelectChipDisplayButtonProps, type MultiSelectChipDisplayProps, MultiSelectContent, type MultiSelectContentProps, MultiSelectContext, type MultiSelectContextActions, type MultiSelectContextComputedState, type MultiSelectContextConfig, type MultiSelectContextIds, type MultiSelectContextLayout, type MultiSelectContextSearch, type MultiSelectContextState, type MultiSelectContextType, type MultiSelectIconAppearance, type MultiSelectIds, MultiSelectOption, MultiSelectOptionDisplayContext, type MultiSelectOptionDisplayLocation, type MultiSelectOptionProps, type MultiSelectOptionType, MultiSelectProperty, type MultiSelectPropertyProps, type MultiSelectProps, MultiSelectRoot, type MultiSelectRootProps, MultiSubjectSearchWithMapping, Navigation, NavigationItemList, type NavigationItemListProps, type NavigationItemType, type NavigationProps, NumberFilterPopUp, NumberProperty, type NumberPropertyProps, type OverlayItem, OverlayRegistry, Pagination, type PaginationProps, PolymorphicSlot, type PolymorphicSlotProps, PopUp, PopUpContext, type PopUpContextType, PopUpOpener, type PopUpOpenerBag, type PopUpOpenerProps, type PopUpProps, PopUpRoot, type PopUpRootProps, Portal, type PortalProps, ProgressIndicator, type ProgressIndicatorProps, PromiseUtils, PropertyBase, type PropertyBaseProps, type PropertyField, PropsUtil, type PropsWithBagFunction, type PropsWithBagFunctionOrChildren, type Range, type RangeOptions, type ResolvedTheme, ScrollPicker, type ScrollPickerProps, SearchBar, type SearchBarProps, Select, SelectButton, type SelectButtonProps, SelectContent, type SelectContentProps, SelectContext, type SelectContextActions, type SelectContextComputedState, type SelectContextConfig, type SelectContextIds, type SelectContextLayout, type SelectContextSearch, type SelectContextState, type SelectContextType, type SelectIconAppearance, type SelectIds, SelectOption, SelectOptionDisplayContext, type SelectOptionDisplayLocation, type SelectOptionProps, type SelectOptionType, type SelectProps, SelectRoot, type SelectRootProps, type SelectionOption, SimpleSearch, SimpleSearchWithMapping, type SingleOrArray, SingleSelectProperty, type SingleSelectPropertyProps, type SingleSelectionReturn, StepperBar, type StepperBarProps, type StepperState, StorageListener, type StorageSubscriber, type SuperSet, Switch, type SwitchProps, type TabContextType, type TabInfo, TabList, TabPanel, TabSwitcher, type TabSwitcherProps, TabView, Table, TableBody, TableCell, type TableCellProps, TableColumn, TableColumnDefinitionContext, type TableColumnDefinitionContextType, type TableColumnProps, TableColumnSwitcher, TableColumnSwitcherPopUp, type TableColumnSwitcherPopUpProps, type TableColumnSwitcherProps, TableContainerContext, type TableContainerContextType, TableDisplay, type TableDisplayProps, TableFilter, TableFilterButton, type TableFilterButtonProps, TableHeader, type TableHeaderProps, TablePageSizeSelect, type TablePageSizeSelectProps, TablePagination, TablePaginationMenu, type TablePaginationMenuProps, type TablePaginationProps, type TableProps, TableProvider, type TableProviderProps, TableSortButton, type TableSortButtonProps, TableStateContext, type TableStateContextType, TableStateWithoutSizingContext, type TableStateWithoutSizingContextType, TableWithSelection, type TableWithSelectionProps, TableWithSelectionProvider, type TableWithSelectionProviderProps, TagIcon, type TagProps, TagsFilterPopUp, type TagsFilterPopUpProps, TagsSingleFilterPopUp, type TagsSingleFilterPopUpProps, TextFilterPopUp, TextImage, type TextImageProps, TextProperty, type TextPropertyProps, Textarea, type TextareaProps, TextareaWithHeadline, type TextareaWithHeadlineProps, type ThemeConfig, ThemeContext, ThemeDialog, type ThemeDialogProps, ThemeIcon, type ThemeIconProps, ThemeProvider, type ThemeProviderProps, ThemeSelect, type ThemeSelectProps, type ThemeType, ThemeUtil, TimeDisplay, TimePicker, type TimePickerMillisecondIncrement, type TimePickerMinuteIncrement, type TimePickerProps, type TimePickerSecondIncrement, ToggleableInput, Tooltip, type TooltipConfig, TooltipContext, type TooltipContextType, TooltipDisplay, type TooltipDisplayProps, type TooltipProps, TooltipRoot, type TooltipRootProps, TooltipTrigger, type TooltipTriggerBag, type TooltipTriggerContextValue, type TooltipTriggerProps, Transition, type TransitionState, type TransitionWrapperProps, type UnBoundedRange, type UseAnchoredPositionOptions, type UseAnchoredPostitionProps, type UseComboboxActions, type UseComboboxComputedState, type UseComboboxOption, type UseComboboxOptions, type UseComboboxReturn, type UseComboboxState, type UseCreateFormProps, type UseCreateFormResult, type UseDelayOptions, type UseDelayOptionsResolved, type UseFocusTrapProps, type UseFormFieldOptions, type UseFormFieldParameter, type UseFormObserverKeyProps, type UseFormObserverProps, type UseMultiSelectActions, type UseMultiSelectComputedState, type UseMultiSelectFirstHighlightBehavior, type UseMultiSelectOption, type UseMultiSelectOptions, type UseMultiSelectReturn, type UseMultiSelectState, type UseMultiSelectionOption, type UseMultiSelectionOptions, type UseMultiSelectionReturn, type UseOutsideClickHandlers, type UseOutsideClickOptions, type UseOutsideClickProps, type UseOverlayRegistryProps, type UseOverlayRegistryResult, type UsePresenceRefProps, type UseResizeObserverProps, type UseSearchOptions, type UseSearchReturn, type UseSelectActions, type UseSelectComputedState, type UseSelectFirstHighlightBehavior, type UseSelectOption, type UseSelectOptions, type UseSelectReturn, type UseSelectState, type UseSingleSelectionOptions, type UseTypeAheadSearchOptions, type UseTypeAheadSearchReturn, type UseUpdatingDateStringProps, UseValidators, type UserFormFieldProps, type ValidatorError, type ValidatorResult, VerticalDivider, type VerticalDividerProps, Visibility, type VisibilityProps, type WeekDay, YearMonthPicker, type YearMonthPickerProps, builder, closestMatch, createLoopingList, createLoopingListWithIndex, equalSizeGroups, getNeighbours, hightideTranslation, hightideTranslationLocales, match, mergeProps, noop, range, resolveSetState, toSizeVars, useAnchoredPosition, useCombobox, useComboboxContext, useControlledState, useCreateForm, useDelay, useDialogContext, useDrawerContext, useEventCallbackStabilizer, useFilterValueTranslation, useFocusGuards, useFocusManagement, useFocusOnceVisible, useFocusTrap, useForm, useFormField, useFormObserver, useFormObserverKey, useHandleRefs, useHightideConfig, useHightideTranslation, useICUTranslation, useIsMounted, useLanguage, useListNavigation, useLocale, useLogOnce, useLogUnstableDependencies, useMultiSelect, useMultiSelectContext, useMultiSelectOptionDisplayLocation, useMultiSelection, useOutsideClick, useOverlayRegistry, useOverwritableState, usePopUpContext, usePresenceRef, useRerender, useResizeObserver, useScrollObserver, useSearch, useSelect, useSelectContext, useSelectOptionDisplayLocation, useSingleSelection, useStorage, useTabContext, useTableColumnDefinitionContext, useTableContainerContext, useTableStateContext, useTableStateWithoutSizingContext, useTheme, useTooltip, useTransitionState, useTranslatedValidators, useTypeAheadSearch, useUpdatingDateString, useWindowResizeObserver, validateEmail, writeToClipboard };