@helpwave/hightide 0.6.5 → 0.6.7

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as react from 'react';
-import react__default, { HTMLAttributes, SVGProps, CSSProperties, ReactNode, PropsWithChildren, RefObject, Dispatch, SetStateAction, ButtonHTMLAttributes, InputHTMLAttributes, ComponentProps, TextareaHTMLAttributes, LabelHTMLAttributes } from 'react';
+import react__default, { HTMLAttributes, SVGProps, CSSProperties, ReactNode, PropsWithChildren, RefObject, Dispatch, SetStateAction, ButtonHTMLAttributes, InputHTMLAttributes, ComponentProps, TableHTMLAttributes, TextareaHTMLAttributes, LabelHTMLAttributes } from 'react';
 import Link from 'next/link';
-import { Column, RowData, FilterFn, ColumnDef, Table as Table$1, InitialTableState, Row, TableState, TableOptions, RowSelectionState, SortDirection } from '@tanstack/react-table';
+import { ColumnDef, Table as Table$1, InitialTableState, Row, TableState, TableOptions, RowData, FilterFn, RowSelectionState, PaginationState, Column, SortDirection, ColumnSizingState } from '@tanstack/react-table';
 import { Translation, TranslationEntries, PartialTranslationExtension } from '@helpwave/internationalization';
 
 type Size = 'sm' | 'md' | 'lg';
@@ -361,6 +361,33 @@ type FormFieldResult<T> = {
 };
 declare function useFormField<T extends FormValue, K extends keyof T>(key: K, { triggerUpdate }: UseFormFieldOptions): FormFieldResult<T[K]> | null;
 
+type FloatingElementAlignment = 'beforeStart' | 'afterStart' | 'center' | 'beforeEnd' | 'afterEnd';
+type CalculatePositionOptions = {
+    verticalAlignment?: FloatingElementAlignment;
+    horizontalAlignment?: FloatingElementAlignment;
+    screenPadding?: number;
+    gap?: number;
+    avoidOverlap?: boolean;
+};
+type UseAnchoredPositionOptions = CalculatePositionOptions & {
+    isPolling?: boolean;
+    pollingInterval?: number;
+};
+type UseAnchoredPostitionProps = UseAnchoredPositionOptions & {
+    container: RefObject<HTMLElement>;
+    anchor: RefObject<HTMLElement>;
+    window?: RefObject<HTMLElement>;
+    active?: boolean;
+};
+declare function useAnchoredPosition({ active, window: windowRef, anchor: anchorRef, container: containerRef, isPolling, pollingInterval, verticalAlignment, horizontalAlignment, avoidOverlap, screenPadding, gap, }: UseAnchoredPostitionProps): CSSProperties;
+
+type BackgroundOverlayProps = HTMLAttributes<HTMLDivElement>;
+interface AnchoredFloatingContainerProps extends HTMLAttributes<HTMLDivElement> {
+    anchor?: RefObject<HTMLElement>;
+    options?: UseAnchoredPositionOptions;
+}
+declare const AnchoredFloatingContainer: react.ForwardRefExoticComponent<AnchoredFloatingContainerProps & react.RefAttributes<HTMLDivElement>>;
+
 interface CarouselSlideProps extends HTMLAttributes<HTMLDivElement> {
     isSelected: boolean;
     index: number;
@@ -410,7 +437,16 @@ type DrawerProps = HTMLAttributes<HTMLDivElement> & {
     backgroundClassName?: string;
     onClose: () => void;
 };
-declare const Drawer: ({ children, isOpen, alignment, titleElement, description, containerClassName, backgroundClassName, onClose, ...props }: DrawerProps) => react.ReactPortal;
+declare const Drawer: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
+    isOpen: boolean;
+    alignment: DrawerAligment;
+    titleElement: ReactNode;
+    description: ReactNode;
+    isAnimated?: boolean;
+    containerClassName?: string;
+    backgroundClassName?: string;
+    onClose: () => void;
+} & react.RefAttributes<HTMLDivElement>>;
 
 type ExpandableRootProps = HTMLAttributes<HTMLDivElement> & {
     isExpanded?: boolean;
@@ -486,58 +522,6 @@ type FAQSectionProps = {
 };
 declare const FAQSection: ({ entries, }: FAQSectionProps) => react_jsx_runtime.JSX.Element;
 
-type FloatingElementAlignment = 'beforeStart' | 'afterStart' | 'center' | 'beforeEnd' | 'afterEnd';
-type CalculatePositionOptions = {
-    verticalAlignment?: FloatingElementAlignment;
-    horizontalAlignment?: FloatingElementAlignment;
-    screenPadding?: number;
-    gap?: number;
-};
-type UseFloatingElementOptions = CalculatePositionOptions & {
-    isPolling?: boolean;
-    pollingInterval?: number;
-};
-type UseFloatingElementProps = UseFloatingElementOptions & {
-    containerRef: RefObject<HTMLElement>;
-    anchorRef: RefObject<HTMLElement>;
-    windowRef?: RefObject<HTMLElement>;
-    active?: boolean;
-};
-declare function useFloatingElement({ active, windowRef, anchorRef, containerRef, isPolling, pollingInterval, verticalAlignment, horizontalAlignment, screenPadding, gap, }: UseFloatingElementProps): CSSProperties;
-
-type FloatingContainerProps = HTMLAttributes<HTMLDivElement> & UseFloatingElementOptions & {
-    anchor?: RefObject<HTMLElement>;
-    /**
-     * Polls the position of the anchor every 100ms
-     *
-     * Use sparingly
-     */
-    backgroundOverlay?: ReactNode;
-};
-/**
- * A floating container that aligns to its anchor
- *
- * Notes:
- * - to hide it use the hidden attribute as other means break the functionality
- */
-declare const FloatingContainer: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
-    verticalAlignment?: FloatingElementAlignment;
-    horizontalAlignment?: FloatingElementAlignment;
-    screenPadding?: number;
-    gap?: number;
-} & {
-    isPolling?: boolean;
-    pollingInterval?: number;
-} & {
-    anchor?: RefObject<HTMLElement>;
-    /**
-     * Polls the position of the anchor every 100ms
-     *
-     * Use sparingly
-     */
-    backgroundOverlay?: ReactNode;
-} & react.RefAttributes<HTMLDivElement>>;
-
 interface InfiniteScrollProps {
     itemCount: number;
     /** How many items to keep in the DOM at once (default: 30) */
@@ -690,6 +674,81 @@ type VisibilityProps = PropsWithChildren & {
 };
 declare function Visibility({ children, isVisible }: VisibilityProps): react_jsx_runtime.JSX.Element;
 
+type DialogPosition = 'top' | 'center' | 'none';
+type DialogProps = HTMLAttributes<HTMLDivElement> & {
+    /** Whether the dialog is currently open */
+    isOpen?: boolean;
+    /** Title of the Dialog used for accessibility */
+    titleElement: ReactNode;
+    /** Description of the Dialog used for accessibility */
+    description: ReactNode;
+    /** Callback when the dialog tries to close */
+    onClose?: () => void;
+    /** Styling for the background */
+    backgroundClassName?: string;
+    /** If true shows a close button and sends onClose on background clicks */
+    isModal?: boolean;
+    position?: DialogPosition;
+    isAnimated?: boolean;
+    containerClassName?: string;
+};
+/**
+ * A generic dialog window which is managed by its parent
+ */
+declare const Dialog: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
+    /** Whether the dialog is currently open */
+    isOpen?: boolean;
+    /** Title of the Dialog used for accessibility */
+    titleElement: ReactNode;
+    /** Description of the Dialog used for accessibility */
+    description: ReactNode;
+    /** Callback when the dialog tries to close */
+    onClose?: () => void;
+    /** Styling for the background */
+    backgroundClassName?: string;
+    /** If true shows a close button and sends onClose on background clicks */
+    isModal?: boolean;
+    position?: DialogPosition;
+    isAnimated?: boolean;
+    containerClassName?: string;
+} & react.RefAttributes<HTMLDivElement>>;
+
+type DialogContextType = {
+    isOpen: boolean;
+    setIsOpen: Dispatch<SetStateAction<boolean>>;
+    isModal: boolean;
+};
+declare const DialogContext: react.Context<DialogContextType>;
+declare function useDialogContext(): DialogContextType;
+
+interface DialogOpenerWrapperBag {
+    open: () => void;
+    close: () => void;
+    isOpen: boolean;
+    toggleOpen: () => void;
+    props: {
+        'onClick': () => void;
+        'aria-haspopup': 'dialog';
+    };
+}
+interface DialogOpenerWrapperProps {
+    children: (props: DialogOpenerWrapperBag) => ReactNode;
+}
+declare function DialogOpenerWrapper({ children }: DialogOpenerWrapperProps): ReactNode;
+interface DialogOpenerPassingProps {
+    'children'?: React.ReactNode;
+    'onClick'?: React.MouseEventHandler<HTMLButtonElement>;
+    'aria-haspopup'?: 'dialog';
+}
+
+interface DialogRootProps extends PropsWithChildren {
+    isOpen?: boolean;
+    onIsOpenChange?: (isOpen: boolean) => void;
+    initialIsOpen?: boolean;
+    isModal?: boolean;
+}
+declare function DialogRoot({ children, isOpen: controlledIsOpen, onIsOpenChange, initialIsOpen, isModal, }: DialogRootProps): react_jsx_runtime.JSX.Element;
+
 /**
  * The different sizes for a button
  */
@@ -737,29 +796,6 @@ declare const Button: react.ForwardRefExoticComponent<ButtonHTMLAttributes<HTMLB
     allowClickEventPropagation?: boolean;
 } & react.RefAttributes<HTMLButtonElement>>;
 
-type DialogPosition = 'top' | 'center' | 'none';
-type DialogProps = HTMLAttributes<HTMLDivElement> & {
-    /** Whether the dialog is currently open */
-    isOpen: boolean;
-    /** Title of the Dialog used for accessibility */
-    titleElement: ReactNode;
-    /** Description of the Dialog used for accessibility */
-    description: ReactNode;
-    /** Callback when the dialog tries to close */
-    onClose?: () => void;
-    /** Styling for the background */
-    backgroundClassName?: string;
-    /** If true shows a close button and sends onClose on background clicks */
-    isModal?: boolean;
-    position?: DialogPosition;
-    isAnimated?: boolean;
-    containerClassName?: string;
-};
-/**
- * A generic dialog window which is managed by its parent
- */
-declare const Dialog: ({ children, isOpen, titleElement, description, isModal, onClose, backgroundClassName, position, containerClassName, ...props }: PropsWithChildren<DialogProps>) => react.ReactPortal;
-
 type ConfirmDialogType = 'positive' | 'negative' | 'neutral' | 'primary';
 type ButtonOverwriteType = {
     text?: string;
@@ -937,17 +973,17 @@ declare const NavigationItemList: ({ items, ...restProps }: NavigationItemListPr
 type NavigationProps = NavigationItemListProps;
 declare const Navigation: ({ ...props }: NavigationProps) => react_jsx_runtime.JSX.Element;
 
-type PaginationProps = {
+interface PaginationProps {
     pageIndex: number;
     pageCount: number;
-    onPageChanged: (page: number) => void;
+    onPageIndexChanged?: (pageIndex: number) => void;
     className?: string;
     style?: CSSProperties;
-};
+}
 /**
  * A Component showing the pagination allowing first, before, next and last page navigation
  */
-declare const Pagination: ({ pageIndex, pageCount, onPageChanged, className, style, }: PaginationProps) => react_jsx_runtime.JSX.Element;
+declare const Pagination: ({ pageIndex, pageCount, onPageIndexChanged, className, style, }: PaginationProps) => react_jsx_runtime.JSX.Element;
 
 type StepperState = {
     currentStep: number;
@@ -969,75 +1005,455 @@ type StepperBarProps = {
 declare const StepperBar: ({ state, numberOfSteps, disabledSteps, onChange, onFinish, finishText, showDots, className, }: StepperBarProps) => react_jsx_runtime.JSX.Element;
 declare const StepperBarUncontrolled: ({ state, onChange, ...props }: StepperBarProps) => react_jsx_runtime.JSX.Element;
 
-type FillerCellProps = HTMLAttributes<HTMLDivElement>;
-declare const FillerCell: ({ ...props }: FillerCellProps) => react_jsx_runtime.JSX.Element;
-
-declare const TableFilters: {
-    dateRange: (row: any, columnId: any, filterValue: [Date | null, Date | null]) => boolean;
+type UseFocusTrapProps = {
+    container: RefObject<HTMLElement>;
+    active: boolean;
+    initialFocus?: RefObject<HTMLElement>;
+    /**
+     * Whether to focus the first element when the initialFocus isn't provided
+     *
+     * Focuses the container instead
+     */
+    focusFirst?: boolean;
 };
+declare const useFocusTrap: ({ container, active, initialFocus, focusFirst, }: UseFocusTrapProps) => void;
 
-type TableFilterType = 'text' | 'range' | 'dateRange';
-type TableFilterButtonProps<T = unknown> = {
-    filterType: TableFilterType;
-    column: Column<T>;
-};
-declare const TableFilterButton: <T>({ filterType, column, }: TableFilterButtonProps<T>) => react_jsx_runtime.JSX.Element;
+interface UseOutsideClickOptions {
+    refs: RefObject<HTMLElement>[];
+    active?: boolean;
+}
+interface UseOutsideClickHandlers {
+    onOutsideClick: (event: MouseEvent | TouchEvent) => void;
+}
+interface UseOutsideClickProps extends UseOutsideClickOptions, UseOutsideClickHandlers {
+}
+declare const useOutsideClick: ({ refs, onOutsideClick, active }: UseOutsideClickProps) => void;
 
-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;
+interface PopUpProps extends AnchoredFloatingContainerProps, Partial<UseOutsideClickHandlers> {
+    isOpen?: boolean;
+    focusTrapOptions?: Omit<UseFocusTrapProps, 'container'>;
+    outsideClickOptions?: UseOutsideClickOptions;
+    onClose?: () => void;
+    forceMount?: boolean;
+    anchorExcludedFromOutsideClick?: boolean;
+}
+declare const PopUp: react.ForwardRefExoticComponent<PopUpProps & react.RefAttributes<HTMLDivElement>>;
+
+type PopUpContextType = {
+    isOpen: boolean;
+    setIsOpen: Dispatch<SetStateAction<boolean>>;
+    popUpId: string;
+    triggerId: string;
+    triggerRef: RefObject<HTMLElement> | null;
+    setTriggerRef: (ref: RefObject<HTMLElement> | null) => void;
 };
+declare const PopUpContext: react.Context<PopUpContextType>;
+declare function usePopUpContext(): PopUpContextType;
+
+interface PopUpOpenerBag<T extends HTMLElement> {
+    open: () => void;
+    close: () => void;
+    isOpen: boolean;
+    toggleOpen: () => void;
+    props: {
+        'id': string;
+        'onClick': () => void;
+        'aria-haspopup': 'dialog';
+        'aria-controls': string;
+        'aria-expanded': boolean;
+        'ref': RefObject<T>;
+    };
+}
+interface PopUpOpenerProps<T extends HTMLElement> {
+    children: (props: PopUpOpenerBag<T>) => ReactNode;
+}
+declare function PopUpOpener<T extends HTMLElement = HTMLButtonElement>({ children }: PopUpOpenerProps<T>): ReactNode;
+
+interface PopUpRootProps extends PropsWithChildren {
+    isOpen?: boolean;
+    onIsOpenChange?: (isOpen: boolean) => void;
+    initialIsOpen?: boolean;
+    popUpId?: string;
+    triggerId?: string;
+}
+declare function PopUpRoot({ children, isOpen: controlledIsOpen, onIsOpenChange, initialIsOpen, popUpId: popUpIdOverwrite, triggerId: triggerIdOverwrite, }: PopUpRootProps): react_jsx_runtime.JSX.Element;
+
+type FillerCellProps = HTMLAttributes<HTMLDivElement>;
+declare const FillerCell: ({ ...props }: FillerCellProps) => react_jsx_runtime.JSX.Element;
+
+type TableProviderProps<T> = {
+    data: T[];
+    columns?: ColumnDef<T>[];
+    children?: ReactNode;
+    isUsingFillerRows?: boolean;
+    fillerRow?: (columnId: string, table: Table$1<T>) => ReactNode;
+    initialState?: Omit<InitialTableState, 'columnSizing'>;
+    onRowClick?: (row: Row<T>, table: Table$1<T>) => void;
+    state?: Omit<TableState, 'columnSizing'>;
+} & Partial<TableOptions<T>>;
+declare const TableProvider: <T>({ data, isUsingFillerRows, fillerRow, initialState, onRowClick, defaultColumn: defaultColumnOverwrite, state, columns: columnsProp, children, ...tableOptions }: TableProviderProps<T>) => react_jsx_runtime.JSX.Element;
 
 declare module '@tanstack/react-table' {
     interface ColumnMeta<TData extends RowData, TValue> {
         className?: string;
-        filterType?: TableFilterType;
+        filterData?: {
+            tags?: {
+                tag: string;
+                label: ReactNode;
+            }[];
+        };
     }
     interface TableMeta<TData> {
         headerRowClassName?: string;
-        bodyRowClassName?: BagFunctionOrValue<TData, string>;
+        bodyRowClassName?: ((value: TData) => string) | string;
     }
     interface FilterFns {
-        dateRange: FilterFn<unknown>;
+        text: FilterFn<unknown>;
+        number: FilterFn<unknown>;
+        date: FilterFn<unknown>;
+        boolean: FilterFn<unknown>;
+        tags: FilterFn<unknown>;
+        generic: FilterFn<unknown>;
     }
 }
-type TableProps<T> = {
-    data: T[];
-    columns: ColumnDef<T>[];
-    fillerRow?: (columnId: string, table: Table$1<T>) => ReactNode;
-    initialState?: Omit<InitialTableState, 'columnSizing' | 'columnSizingInfo'>;
-    className?: string;
-    tableContainerClassName?: string;
-    onRowClick?: (row: Row<T>, table: Table$1<T>) => void;
-    state?: Omit<TableState, 'columnSizing' | 'columnSizingInfo'>;
-    tableClassName?: string;
-} & Partial<TableOptions<T>>;
-/**
- * The standard table
- */
-declare const Table: <T>({ data, fillerRow, initialState, onRowClick, className, tableClassName, tableContainerClassName, defaultColumn, state, columns, ...tableOptions }: TableProps<T>) => react_jsx_runtime.JSX.Element;
-type TableUncontrolledProps<T> = TableProps<T>;
-declare const TableUncontrolled: <T>({ data, ...props }: TableUncontrolledProps<T>) => react_jsx_runtime.JSX.Element;
-type TableWithSelectionProps<T> = TableProps<T> & {
+
+type TableHeaderProps = {
+    table?: Table$1<unknown>;
+    isSticky?: boolean;
+};
+declare const TableHeader: ({ table: tableOverride, isSticky }: TableHeaderProps) => react_jsx_runtime.JSX.Element;
+
+interface TableDisplayProps extends TableHTMLAttributes<HTMLTableElement> {
+    containerProps?: Omit<React.HTMLAttributes<HTMLDivElement>, 'children'>;
+    tableHeaderProps?: Omit<TableHeaderProps, 'children' | 'table'>;
+}
+/**
+ * A display component for a table that requires a TableProvider for the table context
+ */
+declare const TableDisplay: <T>({ children, containerProps, tableHeaderProps, ...props }: TableDisplayProps) => 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 = {
+    isOpen: boolean;
+    options: RegisteredOption[];
+    highlightedValue?: string;
+};
+type SelectContextIds = {
+    trigger: string;
+    content: string;
+};
+type SelectContextState = InternalSelectContextState & FormFieldInteractionStates & {
+    value: string[];
+    selectedOptions: RegisteredOption[];
+};
+type SelectConfiguration = {
+    isMultiSelect: boolean;
+    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>>;
+declare const SelectRoot: ({ value, onValueChange, onEditComplete, ...props }: SelectRootProps) => react_jsx_runtime.JSX.Element;
+type MultiSelectRootProps = SharedSelectRootProps & Partial<FormFieldDataHandling<string[]>>;
+declare const MultiSelectRoot: ({ value, onValueChange, onEditComplete, ...props }: MultiSelectRootProps) => react_jsx_runtime.JSX.Element;
+
+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;
+};
+declare const SelectButton: react.ForwardRefExoticComponent<ButtonHTMLAttributes<HTMLButtonElement> & {
+    placeholder?: ReactNode;
+    selectedDisplay?: (value: string[]) => ReactNode;
+} & 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;
+} & react.RefAttributes<HTMLButtonElement>>;
+
+type SelectProps = SelectRootProps & {
+    contentPanelProps?: SelectContentProps;
+    buttonProps?: Omit<SelectButtonProps, 'selectedDisplay'> & {
+        selectedDisplay?: (value: string) => ReactNode;
+    };
+};
+declare const Select: react.ForwardRefExoticComponent<Partial<FormFieldInteractionStates> & {
+    children?: ReactNode | undefined;
+} & {
+    id?: string;
+    initialIsOpen?: boolean;
+    iconAppearance?: SelectIconAppearance;
+    onClose?: () => void;
+} & Partial<FormFieldDataHandling<string>> & {
+    contentPanelProps?: SelectContentProps;
+    buttonProps?: Omit<SelectButtonProps, "selectedDisplay"> & {
+        selectedDisplay?: (value: string) => ReactNode;
+    };
+} & react.RefAttributes<HTMLButtonElement>>;
+type SelectUncontrolledProps = SelectProps;
+declare const SelectUncontrolled: react.ForwardRefExoticComponent<Partial<FormFieldInteractionStates> & {
+    children?: ReactNode | undefined;
+} & {
+    id?: string;
+    initialIsOpen?: boolean;
+    iconAppearance?: SelectIconAppearance;
+    onClose?: () => void;
+} & Partial<FormFieldDataHandling<string>> & {
+    contentPanelProps?: SelectContentProps;
+    buttonProps?: Omit<SelectButtonProps, "selectedDisplay"> & {
+        selectedDisplay?: (value: string) => ReactNode;
+    };
+} & react.RefAttributes<HTMLButtonElement>>;
+
+declare const TablePaginationMenu: () => react_jsx_runtime.JSX.Element;
+interface TablePageSizeSelectProps extends SelectProps {
+    pageSizeOptions?: number[];
+}
+declare const TablePageSizeSelect: ({ pageSizeOptions, ...props }: TablePageSizeSelectProps) => react_jsx_runtime.JSX.Element;
+interface TablePaginationProps extends HTMLAttributes<HTMLDivElement> {
+    allowChangingPageSize?: boolean;
+    pageSizeOptions?: number[];
+}
+declare const TablePagination: ({ allowChangingPageSize, pageSizeOptions, ...props }: TablePaginationProps) => react_jsx_runtime.JSX.Element;
+
+interface TableWithSelectionProviderProps<T> extends TableProviderProps<T> {
     rowSelection: RowSelectionState;
     disableClickRowClickSelection?: boolean;
     selectionRowId?: string;
-};
-declare const TableWithSelection: <T>({ columns, state, fillerRow, rowSelection, disableClickRowClickSelection, selectionRowId, onRowClick, meta, ...props }: TableWithSelectionProps<T>) => react_jsx_runtime.JSX.Element;
+}
+declare const TableWithSelectionProvider: <T>({ children, state, fillerRow, rowSelection, disableClickRowClickSelection, selectionRowId, onRowClick, meta, ...props }: TableWithSelectionProviderProps<T>) => react_jsx_runtime.JSX.Element;
+
+interface TableProps<T> extends HTMLAttributes<HTMLDivElement> {
+    table: TableProviderProps<T>;
+    paginationOptions?: TablePaginationProps & {
+        showPagination?: boolean;
+    };
+    displayProps?: Omit<TableDisplayProps, 'children'>;
+    header?: React.ReactNode;
+    footer?: React.ReactNode;
+}
+declare const Table: <T>({ children, table, paginationOptions, displayProps, header, footer, ...props }: TableProps<T>) => react_jsx_runtime.JSX.Element;
+interface TableWithSelectionProps<T> extends HTMLAttributes<HTMLDivElement> {
+    table: TableWithSelectionProviderProps<T>;
+    paginationOptions?: TablePaginationProps & {
+        showPagination?: boolean;
+    };
+    displayProps?: Omit<TableDisplayProps, 'children'>;
+    header?: React.ReactNode;
+    footer?: React.ReactNode;
+}
+declare const TableWithSelection: <T>({ children, table, paginationOptions, displayProps, header, footer, ...props }: TableWithSelectionProps<T>) => react_jsx_runtime.JSX.Element;
+
+declare const TableBody: react__default.NamedExoticComponent<object>;
 
 type TableCellProps = PropsWithChildren<{
     className?: string;
 }>;
 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 boolean: readonly ["booleanIsTrue", "booleanIsFalse"];
+    readonly tags: readonly ["tagsEquals", "tagsNotEquals", "tagsContains", "tagsNotContains"];
+    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 TableBooleanFilter = (typeof TableFilterOperator.boolean)[number] | TableGenericFilter;
+type TableTagsFilter = (typeof TableFilterOperator.tags)[number] | TableGenericFilter;
+type TableFilterType = TableTextFilter | TableNumberFilter | TableDateFilter | TableBooleanFilter | TableTagsFilter | TableGenericFilter;
+type TableFilterCategory = keyof typeof TableFilterOperator;
+declare function isTableFilterCategory(value: unknown): value is TableFilterCategory;
+type TextFilterParameter = {
+    searchText?: string;
+};
+type NumberFilterParameter = {
+    compareValue?: number;
+    min?: number;
+    max?: number;
+};
+type DateFilterParameter = {
+    compareDate?: Date;
+    min?: Date;
+    max?: Date;
+};
+type BooleanFilterParameter = Record<string, never>;
+type TagsFilterParameter = {
+    searchTags?: 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 BooleanFilterValue = {
+    operator: TableBooleanFilter;
+    parameter: BooleanFilterParameter;
+};
+type TagsFilterValue = {
+    operator: TableTagsFilter;
+    parameter: TagsFilterParameter;
+};
+type GenericFilterValue = {
+    operator: TableGenericFilter;
+    parameter: GenericFilterParameter;
+};
+type TableFilterValue = TextFilterValue | NumberFilterValue | DateFilterValue | BooleanFilterValue | TagsFilterValue | GenericFilterValue;
+declare const TableFilter: {
+    text: FilterFn<unknown>;
+    number: FilterFn<unknown>;
+    date: FilterFn<unknown>;
+    boolean: FilterFn<unknown>;
+    tags: FilterFn<unknown>;
+    generic: FilterFn<unknown>;
+};
+
+type TableColumnProps<T> = ColumnDef<T> & {
+    filterType?: TableFilterCategory;
+};
+declare const TableColumn: <T>(props: TableColumnProps<T>) => react_jsx_runtime.JSX.Element;
+
+type TableColumnSwitcherPopUpProps = PopUpProps;
+declare const TableColumnSwitcherPopUp: ({ ...props }: TableColumnSwitcherPopUpProps) => react_jsx_runtime.JSX.Element;
+interface TableColumnSwitcherProps extends TableColumnSwitcherPopUpProps {
+    buttonProps?: ButtonProps;
+}
+declare const TableColumnSwitcher: ({ buttonProps, ...props }: TableColumnSwitcherProps) => react_jsx_runtime.JSX.Element;
+
+type TableDataContextType<T> = {
+    table: Table$1<T>;
+    columns: ColumnDef<T>[];
+    rows: Row<T>[];
+    rowSelection: RowSelectionState;
+    data: T[];
+    pagination: PaginationState;
+    isUsingFillerRows: boolean;
+    fillerRow: (columnId: string, table: Table$1<T>) => ReactNode;
+    onRowClick: (row: Row<T>, table: Table$1<T>) => void;
+};
+declare const TableDataContext: react.Context<TableDataContextType<any>>;
+declare const useTableDataContext: <T>() => TableDataContextType<T>;
+type TableColumnDefinitionContextType<T> = {
+    table: Table$1<T>;
+    registerColumn: (column: ColumnDef<T>) => () => void;
+};
+declare const TableColumnDefinitionContext: react.Context<TableColumnDefinitionContextType<any>>;
+declare const useTableColumnDefinitionContext: <T>() => TableColumnDefinitionContextType<T>;
+type TableHeaderContextType<T> = {
+    table: Table$1<T>;
+    sizeVars: Record<string, number>;
+};
+declare const TableHeaderContext: react.Context<TableHeaderContextType<any>>;
+declare const useTableHeaderContext: <T>() => TableHeaderContextType<T>;
+type TableContainerContextType<T> = {
+    table: Table$1<T>;
+    containerRef: RefObject<HTMLDivElement>;
+};
+declare const TableContainerContext: react.Context<TableContainerContextType<any>>;
+declare const useTableContainerContext: <T>() => TableContainerContextType<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 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 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;
+
 type SortingIndexDisplay = {
     index: number;
     sortingsCount: number;
@@ -1052,6 +1468,27 @@ type TableSortButtonProps = ButtonProps & {
  */
 declare const TableSortButton: ({ sortDirection, invert, color, size, className, sortingIndexDisplay, ...props }: TableSortButtonProps) => react_jsx_runtime.JSX.Element;
 
+type ColumnSizeCalculateTargetBehavoir = 'equalOrHigher';
+type ColumnSizeCalculateTarget = {
+    width: number;
+    behaviour: ColumnSizeCalculateTargetBehavoir;
+};
+type ColumnSizeCalculatoProps = {
+    previousSizing: Record<string, number>;
+    newSizing: Record<string, number>;
+    columnIds: string[];
+    target?: ColumnSizeCalculateTarget;
+    minWidthsPerColumn: Record<string, number>;
+    maxWidthsPerColumn?: Record<string, number>;
+};
+declare const toSizeVars: (sizing: ColumnSizingState) => {};
+declare const ColumnSizeUtil: {
+    calculate: ({ previousSizing, newSizing, columnIds, target, minWidthsPerColumn, maxWidthsPerColumn }: ColumnSizeCalculatoProps) => {
+        [x: string]: number;
+    };
+    toSizeVars: (sizing: ColumnSizingState) => {};
+};
+
 type CheckBoxSize = 'sm' | 'md' | 'lg' | null;
 type CheckboxProps = HTMLAttributes<HTMLDivElement> & Partial<FormFieldInteractionStates> & Partial<FormFieldDataHandling<boolean>> & {
     indeterminate?: boolean;
@@ -1098,47 +1535,28 @@ type CopyToClipboardWrapperProps = PropsWithChildren<{
  */
 declare const CopyToClipboardWrapper: ({ children, textToCopy, tooltipClassName, containerClassName, position, zIndex, }: CopyToClipboardWrapperProps) => react_jsx_runtime.JSX.Element;
 
-type PopoverHorizontalAlignment = 'leftOutside' | 'leftInside' | 'rightOutside' | 'rightInside' | 'center';
-type PopoverVerticalAlignment = 'topOutside' | 'topInside' | 'bottomOutside' | 'bottomInside' | 'center';
-type PopoverPositionOptionsResolved = {
-    edgePadding: number;
-    outerGap: number;
-    verticalAlignment: PopoverVerticalAlignment;
-    horizontalAlignment: PopoverHorizontalAlignment;
-    disabled: boolean;
-};
-type PopoverPositionOptions = Partial<PopoverPositionOptionsResolved>;
-declare const usePopoverPosition: (trigger?: DOMRect, options?: PopoverPositionOptions) => CSSProperties;
-
 type MenuItemProps = {
     onClick?: () => void;
-    alignment?: 'left' | 'right';
     isDisabled?: boolean;
     className?: string;
 };
-declare const MenuItem: ({ children, onClick, alignment, isDisabled, className }: PropsWithChildren<MenuItemProps>) => react_jsx_runtime.JSX.Element;
+declare const MenuItem: ({ children, onClick, isDisabled, className }: PropsWithChildren<MenuItemProps>) => react_jsx_runtime.JSX.Element;
 type MenuBag = {
     isOpen: boolean;
     disabled: boolean;
     toggleOpen: () => void;
     close: () => void;
 };
-type MenuProps = {
+interface MenuProps extends Omit<PopUpProps, 'children' | 'anchor'> {
     children: (bag: MenuBag) => ReactNode | ReactNode;
     trigger: (bag: MenuBag, ref: (el: HTMLElement | null) => void) => ReactNode;
-    /**
-     * @default 'l'
-     */
-    alignmentHorizontal?: PopoverHorizontalAlignment;
-    alignmentVertical?: PopoverVerticalAlignment;
     showOnHover?: boolean;
-    menuClassName?: string;
     disabled?: boolean;
-};
+}
 /**
  * A Menu Component to allow the user to see different functions
  */
-declare const Menu: ({ trigger, children, alignmentHorizontal, alignmentVertical, showOnHover, disabled, menuClassName, }: MenuProps) => react_jsx_runtime.JSX.Element;
+declare const Menu: ({ trigger, children, showOnHover, disabled, ...props }: MenuProps) => react_jsx_runtime.JSX.Element;
 
 type ScrollPickerProps<T> = {
     options: T[];
@@ -1199,13 +1617,17 @@ declare const hightideTranslationLocales: readonly ["de-DE", "en-US"];
 type HightideTranslationLocales = typeof hightideTranslationLocales[number];
 type HightideTranslationEntries = {
     'add': string;
+    'after': string;
     'age': string;
     'all': string;
     'apply': string;
     'back': string;
+    'before': string;
+    'between': string;
     'cancel': string;
     'carousel': string;
     'change': string;
+    'changeColumnDisplay': string;
     'chooseLanguage': string;
     'chooseSlide': string;
     'chooseTheme': string;
@@ -1215,10 +1637,16 @@ type HightideTranslationEntries = {
     'clickToCopy': string;
     'clickToSelect': string;
     'close': string;
+    'closeDialog': string;
+    'columnPicker': string;
+    'columnPickerDescription': string;
+    'columns': string;
     'confirm': string;
+    'contains': string;
     'copied': string;
     'copy': string;
     'create': string;
+    'date': string;
     'decline': string;
     'delete': string;
     'discard': string;
@@ -1226,19 +1654,34 @@ type HightideTranslationEntries = {
     'done': string;
     'edit': string;
     'endDate': string;
+    'endsWith': string;
     'enterText': string;
+    'entriesPerPage': string;
     'entryDate': string;
+    'equals': string;
     'error': string;
     'errorOccurred': string;
     'exit': string;
     'fieldRequiredError': string;
     'filter': string;
+    'filterNonWhitespace': string;
+    'filterNotUndefined': string;
+    'filterUndefined': string;
+    'first': string;
     'goodToSeeYou': string;
+    'greaterThan': string;
+    'greaterThanOrEqual': string;
+    'hideColumn': string;
     'identifier': string;
     'invalidEmail': string;
     'invalidEmailError': string;
+    'isFalse': string;
+    'isTrue': string;
     'language': string;
+    'last': string;
     'less': string;
+    'lessThan': string;
+    'lessThanOrEqual': string;
     'loading': string;
     'locale': string;
     'max': string;
@@ -1246,13 +1689,21 @@ type HightideTranslationEntries = {
     'min': string;
     'minLengthError': string;
     'more': string;
+    'moveDown': string;
+    'moveUp': string;
     'name': string;
     'next': string;
     'no': string;
     'none': string;
+    'noParameterRequired': string;
+    'notBetween': string;
+    'notContains': string;
     'notEmpty': string;
+    'notEquals': string;
     'nothingFound': string;
     'of': string;
+    'onOrAfter': string;
+    'onOrBefore': string;
     'optional': string;
     'outOfRangeNumber': (values: {
         min: number;
@@ -1266,6 +1717,10 @@ type HightideTranslationEntries = {
         min: number;
         max: number;
     }) => string;
+    'parameter': string;
+    'pinLeft': string;
+    'pinned': string;
+    'pinRight': string;
     'pleaseWait': string;
     'previous': string;
     'pThemes': (values: {
@@ -1280,13 +1735,18 @@ type HightideTranslationEntries = {
     }) => string;
     'save': string;
     'saved': string;
+    'sDateTimeSelect': (values: {
+        datetimeMode: string;
+    }) => string;
     'search': string;
     'select': string;
+    'selection': string;
     'selectOption': string;
     'sGender': (values: {
         gender: string;
     }) => string;
     'show': string;
+    'showColumn': string;
     'showLess': string;
     'showMore': string;
     'showSlide': (values: {
@@ -1299,12 +1759,15 @@ type HightideTranslationEntries = {
         length: number;
     }) => string;
     'startDate': string;
+    'startsWith': string;
     'sThemeMode': (values: {
         theme: string;
     }) => string;
     'street': string;
     'submit': string;
     'success': string;
+    'tag': string;
+    'tags': string;
     'text': string;
     'time.ago': string;
     'time.agoDays': (values: {
@@ -1377,6 +1840,7 @@ type HightideTranslationEntries = {
     'tooShort': (values: {
         min: number;
     }) => string;
+    'unpin': string;
     'unsavedChanges': string;
     'unsavedChangesSaveQuestion': string;
     'update': string;
@@ -1398,6 +1862,7 @@ type TooltipConfig = {
      * Number of milliseconds until the tooltip appears
      */
     appearDelay: number;
+    isAnimated: boolean;
 };
 type ThemeConfig = {
     /**
@@ -1430,7 +1895,7 @@ declare const HightideConfigProvider: ({ children, ...initialOverwrite }: Highti
 declare const useHightideConfig: () => ConfigType;
 
 type Position = 'top' | 'bottom' | 'left' | 'right';
-type TooltipProps = PropsWithChildren & Partial<TooltipConfig> & {
+interface TooltipProps extends PropsWithChildren, Partial<TooltipConfig> {
     tooltip: ReactNode;
     /**
      * Class names of additional styling properties for the tooltip
@@ -1442,7 +1907,7 @@ type TooltipProps = PropsWithChildren & Partial<TooltipConfig> & {
     containerClassName?: string;
     position?: Position;
     disabled?: boolean;
-};
+}
 /**
  * A Component for showing a tooltip when hovering over Content
  * @param tooltip The tooltip to show can be a text or any ReactNode
@@ -1452,7 +1917,7 @@ type TooltipProps = PropsWithChildren & Partial<TooltipConfig> & {
  * @param position The direction of the tooltip relative to the Container
  * @constructor
  */
-declare const Tooltip: ({ tooltip, children, appearDelay: appearOverwrite, tooltipClassName, containerClassName, position, disabled, }: TooltipProps) => react_jsx_runtime.JSX.Element;
+declare const Tooltip: ({ tooltip, children, appearDelay: appearOverwrite, isAnimated: isAnimatedOverwrite, tooltipClassName, containerClassName, position, disabled, }: TooltipProps) => react_jsx_runtime.JSX.Element;
 
 type DurationJSON = {
     years: number;
@@ -1579,6 +2044,24 @@ type DateTimePickerProps = Partial<FormFieldDataHandling<Date>> & {
 declare const DateTimePicker: ({ value, start, end, mode, is24HourFormat, minuteIncrement, weekStart, onValueChange, onEditComplete, timePickerProps, datePickerProps, }: DateTimePickerProps) => react_jsx_runtime.JSX.Element;
 declare const DateTimePickerUncontrolled: ({ value: initialValue, onValueChange, ...props }: DateTimePickerProps) => react_jsx_runtime.JSX.Element;
 
+interface ControlledStateProps<T> {
+    value?: T;
+    onValueChange?: (value: T) => void;
+    defaultValue?: T;
+    isControlled?: boolean;
+}
+declare const useControlledState: <T>({ value, onValueChange, defaultValue, isControlled: isEnforcingControlled }: ControlledStateProps<T>) => [T, react__default.Dispatch<react__default.SetStateAction<T>>];
+
+interface DateTimePickerDialogProps extends ControlledStateProps<Date | null> {
+    allowRemove?: boolean;
+    onEditComplete?: (value: Date | null) => void;
+    pickerProps: Omit<DateTimePickerProps, 'value' | 'onValueChange' | 'onEditComplete'>;
+    mode?: 'date' | 'dateTime';
+    label?: ReactNode;
+    labelId?: string;
+}
+declare const DateTimePickerDialog: ({ defaultValue, value, allowRemove, onValueChange, onEditComplete, isControlled, mode, pickerProps, labelId, label, }: DateTimePickerDialogProps) => react_jsx_runtime.JSX.Element;
+
 type TimeDisplayMode = 'daysFromToday' | 'date';
 type TimeDisplayProps = {
     date: Date;
@@ -1589,14 +2072,20 @@ type TimeDisplayProps = {
  */
 declare const TimeDisplay: ({ date, mode }: TimeDisplayProps) => react_jsx_runtime.JSX.Element;
 
-type DateTimeInputProps = Omit<InputProps, keyof FormFieldDataHandling<string>> & Partial<FormFieldDataHandling<Date>> & {
-    onRemove?: () => void;
+type DateTimeInputHandle = {
+    input: HTMLDivElement | null;
+    popup: HTMLDivElement | null;
+};
+interface DateTimeInputProps extends Partial<FormFieldInteractionStates>, ControlledStateProps<Date | null>, Omit<ButtonHTMLAttributes<HTMLDivElement>, 'defaultValue' | 'value'>, Partial<FormFieldDataHandling<Date | null>> {
+    placeholder?: ReactNode;
+    allowRemove?: boolean;
     mode?: 'date' | 'dateTime';
     containerProps?: HTMLAttributes<HTMLDivElement>;
     pickerProps?: Omit<DateTimePickerProps, keyof FormFieldDataHandling<Date> | 'mode'>;
-};
-declare const DateTimeInput: ({ value, onValueChange, onEditComplete, onRemove, containerProps, mode, pickerProps, ...props }: DateTimeInputProps) => react_jsx_runtime.JSX.Element;
-declare const DateTimeInputUncontrolled: ({ value: initialValue, ...props }: DateTimeInputProps) => react_jsx_runtime.JSX.Element;
+    outsideClickCloses?: boolean;
+    onDialogOpeningChange?: (isOpen: boolean) => void;
+}
+declare const DateTimeInput: react.ForwardRefExoticComponent<DateTimeInputProps & react.RefAttributes<DateTimeInputHandle>>;
 
 type InsideLabelInputProps = Omit<InputProps, 'aria-label' | 'aria-labelledby' | 'placeholder'> & {
     label: ReactNode;
@@ -1710,116 +2199,6 @@ type TextPropertyProps = PropertyField<string>;
  */
 declare const TextProperty: ({ value, readOnly, onRemove, onValueChange, onEditComplete, ...baseProps }: TextPropertyProps) => 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 = {
-    isOpen: boolean;
-    options: RegisteredOption[];
-    highlightedValue?: string;
-};
-type SelectContextIds = {
-    trigger: string;
-    content: string;
-};
-type SelectContextState = InternalSelectContextState & FormFieldInteractionStates & {
-    value: string[];
-    selectedOptions: RegisteredOption[];
-};
-type SelectConfiguration = {
-    isMultiSelect: boolean;
-    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>>;
-declare const SelectRoot: ({ value, onValueChange, onEditComplete, ...props }: SelectRootProps) => react_jsx_runtime.JSX.Element;
-type MultiSelectRootProps = SharedSelectRootProps & Partial<FormFieldDataHandling<string[]>>;
-declare const MultiSelectRoot: ({ value, onValueChange, onEditComplete, ...props }: MultiSelectRootProps) => react_jsx_runtime.JSX.Element;
-
-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;
-};
-declare const SelectButton: react.ForwardRefExoticComponent<ButtonHTMLAttributes<HTMLButtonElement> & {
-    placeholder?: ReactNode;
-    selectedDisplay?: (value: string[]) => ReactNode;
-} & react.RefAttributes<HTMLButtonElement>>;
-type Orientation = 'vertical' | 'horizontal';
-type SelectContentProps = HTMLAttributes<HTMLUListElement> & {
-    alignment?: Pick<UseFloatingElementOptions, 'gap' | 'horizontalAlignment' | 'verticalAlignment'>;
-    orientation?: Orientation;
-    containerClassName?: string;
-};
-declare const SelectContent: react.ForwardRefExoticComponent<HTMLAttributes<HTMLUListElement> & {
-    alignment?: Pick<UseFloatingElementOptions, "gap" | "horizontalAlignment" | "verticalAlignment">;
-    orientation?: Orientation;
-    containerClassName?: string;
-} & 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<HTMLAttributes<HTMLUListElement> & {
-    alignment?: Pick<UseFloatingElementOptions, "gap" | "horizontalAlignment" | "verticalAlignment">;
-    orientation?: Orientation;
-    containerClassName?: string;
-} & react.RefAttributes<HTMLUListElement>>;
-type MultiSelectButtonProps = SelectButtonProps;
-declare const MultiSelectButton: react.ForwardRefExoticComponent<ButtonHTMLAttributes<HTMLButtonElement> & {
-    placeholder?: ReactNode;
-    selectedDisplay?: (value: string[]) => ReactNode;
-} & react.RefAttributes<HTMLButtonElement>>;
-
 type MultiSelectProps = MultiSelectRootProps & {
     contentPanelProps?: MultiSelectContentProps;
     buttonProps?: MultiSelectButtonProps;
@@ -1883,63 +2262,33 @@ declare const MultiSelectChipDisplayUncontrolled: react.ForwardRefExoticComponen
     chipDisplayProps?: MultiSelectChipDisplayButtonProps;
 } & react.RefAttributes<HTMLDivElement>>;
 
-type SelectProps = SelectRootProps & {
-    contentPanelProps?: SelectContentProps;
-    buttonProps?: Omit<SelectButtonProps, 'selectedDisplay'> & {
-        selectedDisplay?: (value: string) => ReactNode;
-    };
-};
-declare const Select: react.ForwardRefExoticComponent<Partial<FormFieldInteractionStates> & {
-    children?: ReactNode | undefined;
-} & {
-    id?: string;
-    initialIsOpen?: boolean;
-    iconAppearance?: SelectIconAppearance;
-    onClose?: () => void;
-} & Partial<FormFieldDataHandling<string>> & {
-    contentPanelProps?: SelectContentProps;
-    buttonProps?: Omit<SelectButtonProps, "selectedDisplay"> & {
-        selectedDisplay?: (value: string) => ReactNode;
-    };
-} & react.RefAttributes<HTMLButtonElement>>;
-type SelectUncontrolledProps = SelectProps;
-declare const SelectUncontrolled: react.ForwardRefExoticComponent<Partial<FormFieldInteractionStates> & {
-    children?: ReactNode | undefined;
-} & {
-    id?: string;
-    initialIsOpen?: boolean;
-    iconAppearance?: SelectIconAppearance;
-    onClose?: () => void;
-} & Partial<FormFieldDataHandling<string>> & {
-    contentPanelProps?: SelectContentProps;
-    buttonProps?: Omit<SelectButtonProps, "selectedDisplay"> & {
-        selectedDisplay?: (value: string) => ReactNode;
-    };
-} & react.RefAttributes<HTMLButtonElement>>;
-
-type FocusTrapProps = HTMLAttributes<HTMLDivElement> & {
-    active?: boolean;
-    initialFocus?: RefObject<HTMLElement | null>;
-    /**
-     * Whether to focus the first element when the initialFocus isn't provided
-     *
-     * Focuses the container instead
-     */
-    focusFirst?: boolean;
-};
+interface FocusTrapProps extends PropsWithChildren, UseFocusTrapProps {
+}
+declare const FocusTrap: ({ children, ...props }: FocusTrapProps) => react.ReactNode;
+interface FocusTrapWrapperProps extends HTMLAttributes<HTMLDivElement>, Omit<FocusTrapProps, 'container'> {
+}
 /**
  * A wrapper for the useFocusTrap hook that directly renders it to a div
  */
-declare const FocusTrap: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
-    active?: boolean;
-    initialFocus?: RefObject<HTMLElement | null>;
-    /**
-     * Whether to focus the first element when the initialFocus isn't provided
-     *
-     * Focuses the container instead
-     */
-    focusFirst?: boolean;
-} & react.RefAttributes<HTMLDivElement>>;
+declare const FocusTrapWrapper: react.ForwardRefExoticComponent<FocusTrapWrapperProps & react.RefAttributes<HTMLDivElement>>;
+
+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;
@@ -1998,21 +2347,11 @@ declare function useFocusManagement(): {
 
 declare const useFocusOnceVisible: (ref: RefObject<HTMLElement>, disable?: boolean) => void;
 
-type UseFocusTrapProps = {
-    container: RefObject<HTMLElement>;
-    active?: boolean;
-    initialFocus?: RefObject<HTMLElement>;
-    /**
-     * Whether to focus the first element when the initialFocus isn't provided
-     *
-     * Focuses the container instead
-     */
-    focusFirst?: boolean;
-};
-declare const useFocusTrap: ({ container, active, initialFocus, focusFirst, }: UseFocusTrapProps) => void;
-
 declare const useIsMounted: () => boolean;
 
+type ElementHandle = Record<string, HTMLElement | null>;
+declare function useHandleRefs<T extends ElementHandle>(handleRef: RefObject<T>): RefObject<HTMLElement | null>[];
+
 type UseHoverStateProps = {
     /**
      * The delay after which the menu is closed in milliseconds
@@ -2072,12 +2411,34 @@ type OptionsResolved = {
 type Options = Partial<OptionsResolved>;
 declare const useLogOnce: (message: string, condition: boolean, options?: Options) => void;
 
-declare const useOutsideClick: <Ts extends RefObject<HTMLElement>[]>(refs: Ts, handler: () => void) => void;
+declare function useLogUnstableDependencies<T extends Record<string, unknown>>(name: string, value: T): void;
 
 type OverlayItem = {
     id: string;
     tags?: string[];
 };
+type OverlayItemInformation = OverlayItem & {
+    zIndex: number;
+    position: number;
+    tagPositions: Record<string, number>;
+};
+type OverlayRegistryValue = {
+    itemInformation: Record<string, OverlayItemInformation>;
+    tagItemCounts: Record<string, number>;
+    activeId: string | null;
+};
+type OverlayRegistryListenerCallback = (value: OverlayRegistryValue) => void;
+declare class OverlayRegistry {
+    private static instance;
+    static getInstance(): OverlayRegistry;
+    private overlayIds;
+    private overlayItems;
+    private listeners;
+    register(item: OverlayItem): () => void;
+    update(item: OverlayItem): void;
+    addListener(callback: OverlayRegistryListenerCallback): () => void;
+    private notify;
+}
 type UseOverlayRegistryProps = Partial<OverlayItem> & {
     isActive?: boolean;
     /** Tags cannot change on every render, thus make sure they are wrapped in a useMemo or similar */
@@ -2088,13 +2449,21 @@ type UseOverlayRegistryResult = {
     zIndex?: number;
     position?: number;
     tagPositions?: Record<string, number>;
-    hasAppeared: boolean;
     tagItemCounts: Record<string, number>;
 };
 declare const useOverlayRegistry: (props?: UseOverlayRegistryProps) => UseOverlayRegistryResult;
 
 declare const useOverwritableState: <T>(overwriteValue?: T, onChange?: (value: T) => void) => [T, react__default.Dispatch<react__default.SetStateAction<T>>];
 
+interface UsePresenceRefProps {
+    isOpen?: boolean;
+}
+declare const usePresenceRef: <T extends HTMLElement>({ isOpen, }: UsePresenceRefProps) => {
+    isPresent: boolean;
+    ref: react.RefObject<T>;
+    refAssignment: (node: T | null) => void;
+};
+
 declare const useRerender: () => react.ActionDispatch<[]>;
 
 /**
@@ -2130,18 +2499,14 @@ type TransitionState = 'opened' | 'closed' | 'opening' | 'closing';
 type UseTransitionStateResult = {
     transitionState: TransitionState;
     isVisible: boolean;
-    callbacks: {
-        onAnimationStart: () => void;
-        onAnimationEnd: () => void;
-        onTransitionStart: () => void;
-        onTransitionEnd: () => void;
-        onTransitionCancel: () => void;
-    };
 };
 type UseTransitionStateProps = {
     isOpen: boolean;
+    initialState?: TransitionState;
+    ref?: RefObject<HTMLElement>;
+    timeout?: number;
 };
-declare const useTransitionState: ({ isOpen }: UseTransitionStateProps) => UseTransitionStateResult;
+declare const useTransitionState: ({ isOpen, initialState, ref, timeout: initialTimeout, }: UseTransitionStateProps) => UseTransitionStateResult;
 
 type ValidatorError = 'notEmpty' | 'invalidEmail' | 'tooLong' | 'tooShort' | 'outOfRangeString' | 'outOfRangeNumber' | 'outOfRangeSelectionItems' | 'tooFewSelectionItems' | 'tooManySelectionItems';
 type ValidatorResult = ValidatorError | undefined;
@@ -2262,7 +2627,13 @@ declare class LoopingArrayCalculator {
 
 declare const match: <K extends string | number | symbol, V>(key: K, values: Record<K, V>) => Record<K, V>[K];
 
-declare const clamp: (value: number, range?: [number, number]) => number;
+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;
 
@@ -2296,7 +2667,7 @@ declare function click<T>(onClick: () => void): {
     onClick: () => void;
     onKeyDown: react__default.KeyboardEventHandler<T>;
 };
-declare function close<T>(onClose: () => void): 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;
@@ -2304,6 +2675,7 @@ type NavigateType<T> = {
     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: {
@@ -2322,6 +2694,7 @@ declare const PropsUtil: {
         navigate: typeof navigate;
         interactionStates: typeof interactionStatesAria;
     };
+    mergeProps: typeof mergeProps;
 };
 
 declare function resolveSetState<T>(action: SetStateAction<T>, prev: T): T;
@@ -2392,4 +2765,4 @@ declare class SessionStorageService extends StorageService {
 
 declare const writeToClipboard: (text: string) => Promise<void>;
 
-export { ASTNodeInterpreter, type ASTNodeInterpreterProps, AnimatedRing, type AnimatedRingProps, ArrayUtil, Avatar, AvatarGroup, type AvatarGroupProps, type AvatarProps, type AvatarSize, type BagFunction, type BagFunctionOrNode, type BagFunctionOrValue, BagFunctionUtil, 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, CheckboxUncontrolled, type CheckboxUncontrolledProps, Chip, type ChipColor, ChipList, type ChipListProps, type ChipProps, ChipUtil, Circle, type CircleProps, ConfirmDialog, type ConfirmDialogProps, type ConfirmDialogType, CopyToClipboardWrapper, type CopyToClipboardWrapperProps, type Crumb, DatePicker, type DatePickerProps, DatePickerUncontrolled, DateProperty, type DatePropertyProps, DateTimeInput, type DateTimeInputProps, DateTimeInputUncontrolled, DateTimePicker, type DateTimePickerMode, type DateTimePickerProps, DateTimePickerUncontrolled, DateUtils, DayPicker, type DayPickerProps, DayPickerUncontrolled, type DeepPartial, Dialog, type DialogPosition, type DialogProps, type Direction, DiscardChangesDialog, DividerInserter, type DividerInserterProps, Drawer, type DrawerAligment, type DrawerProps, Duration, type DurationJSON, type EaseFunction, EaseFunctions, type EditCompleteOptions, type EditCompleteOptionsResolved, ErrorComponent, type ErrorComponentProps, type Exact, Expandable, ExpandableContent, type ExpandableContentProps, ExpandableHeader, type ExpandableHeaderProps, type ExpandableProps, ExpandableRoot, type ExpandableRootProps, ExpandableUncontrolled, ExpansionIcon, type ExpansionIconProps, type FAQItem, FAQSection, type FAQSectionProps, FillerCell, type FillerCellProps, FloatingContainer, type FloatingContainerProps, type FloatingElementAlignment, FocusTrap, type FocusTrapProps, 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, FormProvider, type FormProviderProps, FormStore, type FormStoreProps, type FormValidationBehaviour, type FormValidator, type FormValue, HelpwaveBadge, type HelpwaveBadgeProps, HelpwaveLogo, type HelpwaveProps, type HighlightStartPositionBehavior, type HightideConfig, HightideConfigContext, HightideConfigProvider, type HightideConfigProviderProps, HightideProvider, type HightideTranslationEntries, type HightideTranslationLocales, InfiniteScroll, type InfiniteScrollProps, Input, InputDialog, type InputModalProps, type InputProps, InputUncontrolled, InsideLabelInput, InsideLabelInputUncontrolled, LanguageDialog, ListBox, ListBoxItem, type ListBoxItemProps, ListBoxMultiple, type ListBoxMultipleProps, ListBoxMultipleUncontrolled, type ListBoxMultipleUncontrolledProps, ListBoxPrimitive, type ListBoxPrimitiveProps, type ListBoxProps, ListBoxUncontrolled, type ListBoxUncontrolledProps, LoadingAndErrorComponent, type LoadingAndErrorComponentProps, LoadingAnimation, type LoadingAnimationProps, type LoadingComponentProps, LoadingContainer, LocalStorageService, LocaleContext, type LocaleContextValue, LocaleProvider, type LocaleProviderProps, type LocalizationConfig, LocalizationUtil, LoopingArrayCalculator, MarkdownInterpreter, type MarkdownInterpreterProps, Menu, type MenuBag, MenuItem, type MenuItemProps, type MenuProps, type Month, MultiSearchWithMapping, MultiSelect, MultiSelectButton, type MultiSelectButtonProps, MultiSelectChipDisplay, MultiSelectChipDisplayButton, type MultiSelectChipDisplayProps, MultiSelectChipDisplayUncontrolled, type MultiSelectChipDisplayUncontrolledProps, MultiSelectContent, type MultiSelectContentProps, MultiSelectOption, type MultiSelectOptionProps, MultiSelectProperty, type MultiSelectPropertyProps, type MultiSelectProps, MultiSelectRoot, type MultiSelectRootProps, MultiSelectUncontrolled, MultiSubjectSearchWithMapping, Navigation, NavigationItemList, type NavigationItemListProps, type NavigationItemType, type NavigationProps, NumberProperty, type NumberPropertyProps, type OverlayItem, Pagination, type PaginationProps, type PopoverHorizontalAlignment, type PopoverVerticalAlignment, ProgressIndicator, type ProgressIndicatorProps, PromiseUtils, PropertyBase, type PropertyBaseProps, type PropertyField, PropsUtil, type PropsWithBagFunction, type PropsWithBagFunctionOrChildren, RadialRings, type RadialRingsProps, type RangeOptions, type ResolvedTheme, Ring, type RingProps, RingWave, type RingWaveProps, ScrollPicker, type ScrollPickerProps, SearchBar, type SearchBarProps, Select, SelectButton, type SelectButtonProps, SelectContent, type SelectContentProps, SelectContext, type SelectIconAppearance, SelectOption, type SelectOptionProps, type SelectProps, SelectRoot, type SelectRootProps, SelectUncontrolled, type SelectUncontrolledProps, SessionStorageService, type SharedSelectRootProps, SimpleSearch, SimpleSearchWithMapping, type SingleOrArray, SingleSelectProperty, type SingleSelectPropertyProps, StepperBar, type StepperBarProps, StepperBarUncontrolled, type StepperState, type SuperSet, type TabContextType, type TabInfo, TabList, TabPanel, TabSwitcher, type TabSwitcherProps, TabView, Table, TableCell, type TableCellProps, TableFilterButton, type TableFilterButtonProps, type TableFilterType, TableFilters, type TableProps, TableSortButton, type TableSortButtonProps, TableUncontrolled, type TableUncontrolledProps, TableWithSelection, type TableWithSelectionProps, TagIcon, type TagProps, TextImage, type TextImageProps, TextProperty, type TextPropertyProps, Textarea, type TextareaProps, TextareaUncontrolled, TextareaWithHeadline, type TextareaWithHeadlineProps, type ThemeConfig, ThemeContext, ThemeDialog, ThemeProvider, type ThemeProviderProps, type ThemeType, ThemeUtil, TimeDisplay, TimePicker, type TimePickerMinuteIncrement, type TimePickerProps, TimePickerUncontrolled, ToggleableInput, ToggleableInputUncontrolled, Tooltip, type TooltipConfig, type TooltipProps, Transition, type TransitionState, type TransitionWrapperProps, type UseCreateFormProps, type UseCreateFormResult, type UseDelayOptions, type UseDelayOptionsResolved, type UseFloatingElementOptions, type UseFloatingElementProps, type UseFocusTrapProps, type UseFormFieldOptions, type UseOverlayRegistryProps, type UseOverlayRegistryResult, type UseSearchProps, UseValidators, type ValidatorError, type ValidatorResult, VerticalDivider, type VerticalDividerProps, Visibility, type VisibilityProps, type WeekDay, YearMonthPicker, type YearMonthPickerProps, YearMonthPickerUncontrolled, addDuration, builder, changeDuration, clamp, closestMatch, createLoopingList, createLoopingListWithIndex, equalSizeGroups, formatDate, formatDateTime, getBetweenDuration, getNeighbours, getWeeksForCalenderMonth, hightideTranslation, hightideTranslationLocales, isInTimeSpan, match, noop, range, resolveSetState, subtractDuration, useCreateForm, useDelay, useFloatingElement, useFocusGuards, useFocusManagement, useFocusOnceVisible, useFocusTrap, useForm, useFormField, useHightideConfig, useHightideTranslation, useHoverState, useICUTranslation, useIsMounted, useLanguage, useLocalStorage, useLocale, useLogOnce, useOutsideClick, useOverlayRegistry, useOverwritableState, usePopoverPosition, useRerender, useResizeCallbackWrapper, useSearch, useSelectContext, useTabContext, useTheme, useTransitionState, useTranslatedValidators, validateEmail, writeToClipboard };
+export { ASTNodeInterpreter, type ASTNodeInterpreterProps, AnchoredFloatingContainer, type AnchoredFloatingContainerProps, AnimatedRing, type AnimatedRingProps, ArrayUtil, 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, CheckboxUncontrolled, type CheckboxUncontrolledProps, Chip, type ChipColor, ChipList, type ChipListProps, type ChipProps, ChipUtil, Circle, type CircleProps, type ColumnSizeCalculatoProps, ColumnSizeUtil, ConfirmDialog, type ConfirmDialogProps, type ConfirmDialogType, type ControlledStateProps, CopyToClipboardWrapper, type CopyToClipboardWrapperProps, type Crumb, DateFilter, type DateFilterParameter, type DateFilterProps, type DateFilterValue, DatePicker, type DatePickerProps, DatePickerUncontrolled, DateProperty, type DatePropertyProps, DateTimeInput, type DateTimeInputHandle, type DateTimeInputProps, DateTimePicker, DateTimePickerDialog, type DateTimePickerDialogProps, type DateTimePickerMode, type DateTimePickerProps, DateTimePickerUncontrolled, DateUtils, DayPicker, type DayPickerProps, DayPickerUncontrolled, 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, type DrawerProps, 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, ExpandableUncontrolled, 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, 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, InfiniteScroll, type InfiniteScrollProps, Input, InputDialog, type InputModalProps, type InputProps, InputUncontrolled, InsideLabelInput, InsideLabelInputUncontrolled, LanguageDialog, ListBox, ListBoxItem, type ListBoxItemProps, ListBoxMultiple, type ListBoxMultipleProps, ListBoxMultipleUncontrolled, type ListBoxMultipleUncontrolledProps, ListBoxPrimitive, type ListBoxPrimitiveProps, type ListBoxProps, ListBoxUncontrolled, type ListBoxUncontrolledProps, LoadingAndErrorComponent, type LoadingAndErrorComponentProps, LoadingAnimation, type LoadingAnimationProps, type LoadingComponentProps, LoadingContainer, LocalStorageService, 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, MultiSelectChipDisplayUncontrolled, type MultiSelectChipDisplayUncontrolledProps, MultiSelectContent, type MultiSelectContentProps, MultiSelectOption, type MultiSelectOptionProps, MultiSelectProperty, type MultiSelectPropertyProps, type MultiSelectProps, MultiSelectRoot, type MultiSelectRootProps, MultiSelectUncontrolled, 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, RadialRings, type RadialRingsProps, type Range, type RangeOptions, type ResolvedTheme, Ring, type RingProps, RingWave, type RingWaveProps, ScrollPicker, type ScrollPickerProps, SearchBar, type SearchBarProps, Select, SelectButton, type SelectButtonProps, SelectContent, type SelectContentProps, SelectContext, type SelectIconAppearance, SelectOption, type SelectOptionProps, type SelectProps, SelectRoot, type SelectRootProps, SelectUncontrolled, type SelectUncontrolledProps, SessionStorageService, type SharedSelectRootProps, SimpleSearch, SimpleSearchWithMapping, type SingleOrArray, SingleSelectProperty, type SingleSelectPropertyProps, StepperBar, type StepperBarProps, StepperBarUncontrolled, type StepperState, type SuperSet, 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, TableDataContext, type TableDataContextType, type TableDateFilter, TableDisplay, type TableDisplayProps, TableFilter, type TableFilterBaseProps, TableFilterButton, type TableFilterButtonProps, type TableFilterCategory, TableFilterContent, type TableFilterContentProps, TableFilterOperator, type TableFilterType, type TableFilterValue, type TableGenericFilter, TableHeader, TableHeaderContext, type TableHeaderContextType, type TableHeaderProps, type TableNumberFilter, TablePageSizeSelect, type TablePageSizeSelectProps, TablePagination, TablePaginationMenu, type TablePaginationProps, type TableProps, TableProvider, type TableProviderProps, TableSortButton, type TableSortButtonProps, type TableTagsFilter, type TableTextFilter, TableWithSelection, type TableWithSelectionProps, TableWithSelectionProvider, type TableWithSelectionProviderProps, TagIcon, type TagProps, TagsFilter, type TagsFilterParameter, type TagsFilterProps, type TagsFilterValue, TextFilter, type TextFilterParameter, type TextFilterProps, type TextFilterValue, TextImage, type TextImageProps, TextProperty, type TextPropertyProps, Textarea, type TextareaProps, TextareaUncontrolled, TextareaWithHeadline, type TextareaWithHeadlineProps, type ThemeConfig, ThemeContext, ThemeDialog, ThemeProvider, type ThemeProviderProps, type ThemeType, ThemeUtil, TimeDisplay, TimePicker, type TimePickerMinuteIncrement, type TimePickerProps, TimePickerUncontrolled, ToggleableInput, ToggleableInputUncontrolled, Tooltip, type TooltipConfig, type TooltipProps, Transition, type TransitionState, type TransitionWrapperProps, type UnBoundedRange, type UseAnchoredPositionOptions, type UseAnchoredPostitionProps, type UseCreateFormProps, type UseCreateFormResult, type UseDelayOptions, type UseDelayOptionsResolved, type UseFocusTrapProps, type UseFormFieldOptions, type UseOutsideClickHandlers, type UseOutsideClickOptions, type UseOutsideClickProps, type UseOverlayRegistryProps, type UseOverlayRegistryResult, type UsePresenceRefProps, type UseSearchProps, UseValidators, type ValidatorError, type ValidatorResult, VerticalDivider, type VerticalDividerProps, Visibility, type VisibilityProps, type WeekDay, YearMonthPicker, type YearMonthPickerProps, YearMonthPickerUncontrolled, addDuration, builder, changeDuration, closestMatch, createLoopingList, createLoopingListWithIndex, equalSizeGroups, formatDate, formatDateTime, getBetweenDuration, getNeighbours, getWeeksForCalenderMonth, hightideTranslation, hightideTranslationLocales, isInTimeSpan, isTableFilterCategory, match, mergeProps, noop, range, resolveSetState, subtractDuration, toSizeVars, useAnchoredPosition, useControlledState, useCreateForm, useDelay, useDialogContext, useFocusGuards, useFocusManagement, useFocusOnceVisible, useFocusTrap, useForm, useFormField, useHandleRefs, useHightideConfig, useHightideTranslation, useHoverState, useICUTranslation, useIsMounted, useLanguage, useLocalStorage, useLocale, useLogOnce, useLogUnstableDependencies, useOutsideClick, useOverlayRegistry, useOverwritableState, usePopUpContext, usePresenceRef, useRerender, useResizeCallbackWrapper, useSearch, useSelectContext, useTabContext, useTableColumnDefinitionContext, useTableContainerContext, useTableDataContext, useTableHeaderContext, useTheme, useTransitionState, useTranslatedValidators, validateEmail, writeToClipboard };