@helpwave/hightide 0.1.46 → 0.1.48

package/dist/index.d.ts

@@ -1,113 +1,2014 @@
-export { generateShadingColors } from './coloring/shading.js';
-export { ColorMode, ColorShadingValue, Coloring, ColoringStyle, ShadedColors, shadingColorValues } from './coloring/types.js';
-export { HelpwaveBadge, HelpwaveBadgeProps } from './components/branding/HelpwaveBadge.js';
-export { DatePicker, DatePickerProps, DatePickerUncontrolled } from './components/date/DatePicker.js';
-export { DayPicker, DayPickerProps, DayPickerUncontrolled } from './components/date/DayPicker.js';
-export { TimeDisplay } from './components/date/TimeDisplay.js';
-export { TimePicker, TimePickerProps, TimePickerUncontrolled } from './components/date/TimePicker.js';
-export { YearMonthPicker, YearMonthPickerProps, YearMonthPickerUncontrolled } from './components/date/YearMonthPicker.js';
-export { ConfirmDialog, ConfirmDialogProps, ConfirmDialogType } from './components/dialog/ConfirmDialog.js';
-export { Dialog, DialogPosition, DialogProps } from './components/dialog/Dialog.js';
-export { DiscardChangesDialog } from './components/dialog/DiscardChangesDialog.js';
-export { InputDialog, InputModalProps } from './components/dialog/InputDialog.js';
-export { LanguageDialog } from './components/dialog/LanguageDialog.js';
-export { ThemeDialog } from './components/dialog/ThemeDialog.js';
-export { FormElementStateProperties, FormElementWrapper, FormElementWrapperProps } from './components/form/FormElementWrapper.js';
-export { Avatar, AvatarGroup, AvatarGroupProps, AvatarProps, AvatarSize, AvatarUtil } from './components/icons-and-geometry/Avatar.js';
-export { Circle, CircleProps } from './components/icons-and-geometry/Circle.js';
-export { HelpwaveLogo, HelpwaveProps } from './components/icons-and-geometry/HelpwaveLogo.js';
-export { AnimatedRing, AnimatedRingProps, RadialRings, RadialRingsProps, Ring, RingProps, RingWave, RingWaveProps } from './components/icons-and-geometry/Ring.js';
-export { TagIcon, TagProps } from './components/icons-and-geometry/Tag.js';
-export { Carousel, CarouselProps, CarouselSlide, CarouselSlideProps } from './components/layout/Carousel.js';
-export { Chip, ChipColor, ChipList, ChipListProps, ChipProps, ChipUtil } from './components/layout/Chip.js';
-export { DividerInserter, DividerInserterProps } from './components/layout/DividerInserter.js';
-export { Expandable, ExpandableProps, ExpandableUncontrolled, ExpansionIcon, ExpansionIconProps } from './components/layout/Expandable.js';
-export { FAQItem, FAQSection, FAQSectionProps } from './components/layout/FAQSection.js';
-export { FloatingContainer, FloatingContainerProps } from './components/layout/FloatingContainer.js';
-export { ListBox, ListBoxItem, ListBoxItemProps, ListBoxMultiple, ListBoxMultipleProps, ListBoxMultipleUncontrolled, ListBoxMultipleUncontrolledProps, ListBoxPrimitive, ListBoxPrimitiveProps, ListBoxProps, ListBoxUncontrolled, ListBoxUncontrolledProps } from './components/layout/ListBox.js';
-export { ASTNodeInterpreter, ASTNodeInterpreterProps, MarkdownInterpreter, MarkdownInterpreterProps } from './components/layout/MarkdownInterpreter.js';
-export { ScrollArea, ScrollAreaProps, ScrollBarAxis, ScrollBarSize, ScrollBarType } from './components/layout/ScrollArea.js';
-export { TextImage, TextImageProps } from './components/layout/TextImage.js';
-export { VerticalDivider, VerticalDividerProps } from './components/layout/VerticalDivider.js';
-export { ErrorComponent, ErrorComponentProps } from './components/loading-states/ErrorComponent.js';
-export { LoadingAndErrorComponent, LoadingAndErrorComponentProps } from './components/loading-states/LoadingAndErrorComponent.js';
-export { LoadingAnimation, LoadingAnimationProps } from './components/loading-states/LoadingAnimation.js';
-export { LoadingButton } from './components/loading-states/LoadingButton.js';
-export { LoadingComponentProps, LoadingContainer } from './components/loading-states/LoadingContainer.js';
-export { ProgressIndicator, ProgressIndicatorProps } from './components/loading-states/ProgressIndicator.js';
-export { BreadCrumb, Crumb } from './components/navigation/BreadCrumb.js';
-export { Navigation, NavigationItemList, NavigationItemListProps, NavigationItemType, NavigationProps } from './components/navigation/Navigation.js';
-export { Pagination, PaginationProps } from './components/navigation/Pagination.js';
-export { StepperBar, StepperBarProps, StepperBarUncontrolled, StepperState } from './components/navigation/StepperBar.js';
-export { CheckboxProperty, CheckboxPropertyProps } from './components/properties/CheckboxProperty.js';
-export { DateProperty, DatePropertyProps } from './components/properties/DateProperty.js';
-export { MultiSelectProperty, MultiSelectPropertyProps } from './components/properties/MultiSelectProperty.js';
-export { NumberProperty, NumberPropertyProps } from './components/properties/NumberProperty.js';
-export { PropertyBase, PropertyBaseProps } from './components/properties/PropertyBase.js';
-export { SingleSelectProperty, SingleSelectPropertyProps } from './components/properties/SelectProperty.js';
-export { TextProperty, TextPropertyProps } from './components/properties/TextProperty.js';
-export { FillerRowElement, FillerRowElementProps } from './components/table/FillerRowElement.js';
-export { TableFilters } from './components/table/Filter.js';
-export { Table, TableProps, TableUncontrolled, TableUncontrolledProps, TableWithSelection, TableWithSelectionProps } from './components/table/Table.js';
-export { TableCell, TableCellProps } from './components/table/TableCell.js';
-export { TableFilterButton, TableFilterButtonProps, TableFilterType } from './components/table/TableFilterButton.js';
-export { TableSortButton, TableSortButtonProps } from './components/table/TableSortButton.js';
-export { ButtonColorUtil, ButtonProps, ButtonUtil, IconButton, IconButtonColor, IconButtonProps, IconButtonUtil, OutlineButton, OutlineButtonColor, OutlineButtonProps, SolidButton, SolidButtonColor, SolidButtonProps, TextButton, TextButtonColor, TextButtonProps } from './components/user-action/Button.js';
-export { Checkbox, CheckboxProps, CheckboxUncontrolled, CheckboxUncontrolledProps } from './components/user-action/Checkbox.js';
-export { CopyToClipboardWrapper, CopyToClipboardWrapperProps } from './components/user-action/CopyToClipboardWrapper.js';
-export { DateTimePicker, DateTimePickerMode, DateTimePickerProps } from './components/user-action/DateAndTimePicker.js';
-export { Label, LabelProps, LabelType } from './components/user-action/Label.js';
-export { Menu, MenuBag, MenuItem, MenuItemProps, MenuProps } from './components/user-action/Menu.js';
-export { ScrollPicker, ScrollPickerProps } from './components/user-action/ScrollPicker.js';
-export { SearchBar, SearchBarProps } from './components/user-action/SearchBar.js';
-export { Textarea, TextareaProps, TextareaUncontrolled, TextareaWithHeadline, TextareaWithHeadlineProps } from './components/user-action/Textarea.js';
-export { Tooltip, TooltipProps } from './components/user-action/Tooltip.js';
-export { EditCompleteOptions, EditCompleteOptionsResolved, Input, InputProps, InputUncontrolled } from './components/user-action/input/Input.js';
-export { InsideLabelInput, InsideLabelInputUncontrolled } from './components/user-action/input/InsideLabelInput.js';
-export { ToggleableInput, ToggleableInputUncontrolled } from './components/user-action/input/ToggleableInput.js';
-export { MultiSelect, MultiSelectChipDisplay, MultiSelectChipDisplayProps, MultiSelectChipDisplayUncontrolled, MultiSelectChipDisplayUncontrolledProps, MultiSelectProps, MultiSelectUncontrolled, MultiSelectUncontrolledProps, Select, SelectButton, SelectChipDisplay, SelectContent, SelectContentProps, SelectOption, SelectOptionProps, SelectProps, SelectRoot, SelectRootProps, SelectUncontrolled, SelectUncontrolledProps } from './components/user-action/select/Select.js';
-export { FocusTrap, FocusTrapProps } from './components/utils/FocusTrap.js';
-export { Transition, TransitionWrapperProps } from './components/utils/Transition.js';
-export { useFocusGuards } from './hooks/focus/useFocusGuards.js';
-export { useFocusManagement } from './hooks/focus/useFocusManagement.js';
-export { useFocusOnceVisible } from './hooks/focus/useFocusOnceVisible.js';
-export { UseFocusTrapProps, useFocusTrap } from './hooks/focus/useFocusTrap.js';
-export { useIsMounted } from './hooks/focus/useIsMounted.js';
-export { UseDelayOptions, UseDelayOptionsResolved, useDelay } from './hooks/useDelay.js';
-export { FloatingElementAlignment, UseFloatingElementOptions, UseFloatingElementProps, useFloatingElement } from './hooks/useFloatingElement.js';
-export { useHoverState } from './hooks/useHoverState.js';
-export { useLocalStorage } from './hooks/useLocalStorage.js';
-export { useLogOnce } from './hooks/useLogOnce.js';
-export { useOutsideClick } from './hooks/useOutsideClick.js';
-export { useOverwritableState } from './hooks/useOverwritableState.js';
-export { PopoverHorizontalAlignment, PopoverVerticalAlignment, usePopoverPosition } from './hooks/usePopoverPosition.js';
-export { useRerender } from './hooks/useRerender.js';
-export { useResizeCallbackWrapper } from './hooks/useResizeCallbackWrapper.js';
-export { UseSearchProps, useSearch } from './hooks/useSearch.js';
-export { UseValidators, ValidatorError, ValidatorResult, useTranslatedValidators } from './hooks/useValidators.js';
-export { LocaleContext, LocaleContextValue, LocaleProvider, useLanguage, useLocale } from './i18n/LocaleProvider.js';
-export { HightideTranslationEntries, HightideTranslationLocales, hightideTranslation, hightideTranslationLocales } from './i18n/translations.js';
-export { useHightideTranslation, useICUTranslation } from './i18n/useHightideTranslation.js';
-export { LocalizationUtil } from './i18n/util.js';
-export { ResolvedTheme, ThemeContext, ThemeProvider, ThemeType, ThemeUtil, useTheme } from './theming/useTheme.js';
-export { ArrayUtil, RangeOptions, closestMatch, createLoopingList, createLoopingListWithIndex, equalSizeGroups, getNeighbours, range } from './utils/array.js';
-export { BagFunction, BagFunctionOrNode, BagFunctionUtil, PropsWithBagFunction, PropsWithBagFunctionOrChildren } from './utils/bagFunctions.js';
-export { builder } from './utils/builder.js';
-export { Duration, Month, WeekDay, addDuration, changeDuration, equalDate, formatDate, formatDateTime, getBetweenDuration, getDaysInMonth, getWeeksForCalenderMonth, isInTimeSpan, monthsList, subtractDuration, weekDayList } from './utils/date.js';
-export { EaseFunction, EaseFunctions } from './utils/easeFunctions.js';
-export { validateEmail } from './utils/emailValidation.js';
-export { Direction, LoopingArrayCalculator } from './utils/loopingArray.js';
-export { match } from './utils/match.js';
-export { clamp } from './utils/math.js';
-export { noop } from './utils/noop.js';
-export { resolveSetState } from './utils/resolveSetState.js';
-export { MultiSearchWithMapping, MultiSubjectSearchWithMapping, SimpleSearch, SimpleSearchWithMapping } from './utils/simpleSearch.js';
-export { LocalStorageService, SessionStorageService } from './utils/storage.js';
-export { DeepPartial, Exact, SingleOrArray, SuperSet } from './utils/typing.js';
-export { writeToClipboard } from './utils/writeToClipboard.js';
-import 'react/jsx-runtime';
-import 'react';
-import '@radix-ui/react-scroll-area';
-import '@tanstack/react-table';
-import '@radix-ui/react-checkbox';
-import '@helpwave/internationalization';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as React from 'react';
+import React__default, { HTMLAttributes, ButtonHTMLAttributes, ReactNode, PropsWithChildren, InputHTMLAttributes, LabelHTMLAttributes, SVGProps, CSSProperties, MutableRefObject, RefObject, TextareaHTMLAttributes, Dispatch, SetStateAction } from 'react';
+import * as ScrollAreaPrimitive from '@radix-ui/react-scroll-area';
+import { Column, RowData, FilterFn, ColumnDef, Table as Table$1, InitialTableState, Row, TableState, TableOptions, RowSelectionState, SortDirection } from '@tanstack/react-table';
+import { CheckboxProps as CheckboxProps$1 } from '@radix-ui/react-checkbox';
+import { Translation, TranslationEntries, PartialTranslationExtension } from '@helpwave/internationalization';
+
+declare const shadingColorValues: readonly [0, 50, 100, 150, 200, 250, 300, 350, 400, 450, 500, 550, 600, 650, 700, 750, 800, 850, 900, 950, 1000];
+type ColorShadingValue = typeof shadingColorValues[number];
+type ShadedColors = Record<ColorShadingValue, string>;
+type ColoringStyle = 'background' | 'tonal' | 'tonal-opaque' | 'text' | 'text-border';
+type ColorMode = 'light' | 'dark';
+type Coloring = {
+    color: '';
+    style?: ColoringStyle;
+    mode?: ColorMode;
+    hover?: boolean;
+};
+
+declare const generateShadingColors: (partialShading: Omit<Partial<ShadedColors>, "0" | "1000">) => ShadedColors;
+
+type Size = 'sm' | 'md' | 'lg';
+type HelpwaveBadgeProps = HTMLAttributes<HTMLSpanElement> & {
+    size?: Size;
+};
+/**
+ * A Badge with the helpwave logo and the helpwave name
+ */
+declare const HelpwaveBadge: ({ size, ...props }: HelpwaveBadgeProps) => react_jsx_runtime.JSX.Element;
+
+declare const monthsList: readonly ["january", "february", "march", "april", "may", "june", "july", "august", "september", "october", "november", "december"];
+type Month = typeof monthsList[number];
+declare const weekDayList: readonly ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];
+type WeekDay = typeof weekDayList[number];
+declare const formatDate: (date: Date) => string;
+declare const formatDateTime: (date: Date) => string;
+declare const getDaysInMonth: (year: number, month: number) => number;
+type Duration = {
+    years?: number;
+    months?: number;
+    days?: number;
+    hours?: number;
+    minutes?: number;
+    seconds?: number;
+    milliseconds?: number;
+};
+declare const changeDuration: (date: Date, duration: Duration, isAdding?: boolean) => Date;
+declare const addDuration: (date: Date, duration: Duration) => Date;
+declare const subtractDuration: (date: Date, duration: Duration) => Date;
+declare const getBetweenDuration: (startDate: Date, endDate: Date) => Duration;
+/** Checks if a given date is in the range of two dates
+ *
+ * An undefined value for startDate or endDate means no bound for the start or end respectively
+ */
+declare const isInTimeSpan: (value: Date, startDate?: Date, endDate?: Date) => boolean;
+/** Compare two dates on the year, month, day */
+declare const equalDate: (date1: Date, date2: Date) => boolean;
+declare const getWeeksForCalenderMonth: (date: Date, weekStart: WeekDay, weeks?: number) => Date[][];
+
+type DayPickerProps = {
+    displayedMonth: Date;
+    selected?: Date;
+    start?: Date;
+    end?: Date;
+    onChange?: (date: Date) => void;
+    weekStart?: WeekDay;
+    markToday?: boolean;
+    className?: string;
+};
+/**
+ * A component for selecting a day of a month
+ */
+declare const DayPicker: ({ displayedMonth, selected, start, end, onChange, weekStart, markToday, className }: DayPickerProps) => react_jsx_runtime.JSX.Element;
+declare const DayPickerUncontrolled: ({ displayedMonth, selected, onChange, ...restProps }: DayPickerProps) => react_jsx_runtime.JSX.Element;
+
+type YearMonthPickerProps = {
+    displayedYearMonth?: Date;
+    start?: Date;
+    end?: Date;
+    onChange?: (date: Date) => void;
+    className?: string;
+    maxHeight?: number;
+    showValueOpen?: boolean;
+};
+declare const YearMonthPicker: ({ displayedYearMonth, start, end, onChange, className, maxHeight, showValueOpen }: YearMonthPickerProps) => react_jsx_runtime.JSX.Element;
+declare const YearMonthPickerUncontrolled: ({ displayedYearMonth, onChange, ...props }: YearMonthPickerProps) => react_jsx_runtime.JSX.Element;
+
+type DisplayMode = 'yearMonth' | 'day';
+type DatePickerProps = {
+    value?: Date;
+    start?: Date;
+    end?: Date;
+    initialDisplay?: DisplayMode;
+    onChange?: (date: Date) => void;
+    dayPickerProps?: Omit<DayPickerProps, 'displayedMonth' | 'onChange' | 'selected'>;
+    yearMonthPickerProps?: Omit<YearMonthPickerProps, 'displayedYearMonth' | 'onChange' | 'start' | 'end'>;
+    className?: string;
+};
+/**
+ * A Component for picking a date
+ */
+declare const DatePicker: ({ value, start, end, initialDisplay, onChange, yearMonthPickerProps, dayPickerProps, className }: DatePickerProps) => react_jsx_runtime.JSX.Element;
+/**
+ * Example for the Date Picker
+ */
+declare const DatePickerUncontrolled: ({ value, onChange, ...props }: DatePickerProps) => react_jsx_runtime.JSX.Element;
+
+type TimeDisplayMode = 'daysFromToday' | 'date';
+type TimeDisplayProps = {
+    date: Date;
+    mode?: TimeDisplayMode;
+};
+/**
+ * A Component for displaying time and dates in a unified fashion
+ */
+declare const TimeDisplay: ({ date, mode }: TimeDisplayProps) => react_jsx_runtime.JSX.Element;
+
+type MinuteIncrement = '1min' | '5min' | '10min' | '15min' | '30min';
+type TimePickerProps = {
+    time?: Date;
+    onChange?: (time: Date) => void;
+    is24HourFormat?: boolean;
+    minuteIncrement?: MinuteIncrement;
+    maxHeight?: number;
+    className?: string;
+};
+declare const TimePicker: ({ time, onChange, is24HourFormat, minuteIncrement, maxHeight, className }: TimePickerProps) => react_jsx_runtime.JSX.Element;
+declare const TimePickerUncontrolled: ({ time, onChange, ...props }: TimePickerProps) => react_jsx_runtime.JSX.Element;
+
+declare const ButtonColorUtil: {
+    solid: readonly ["primary", "secondary", "tertiary", "positive", "warning", "negative", "neutral"];
+    text: readonly ["primary", "negative", "neutral"];
+    outline: readonly ["primary"];
+};
+declare const IconButtonUtil: {
+    icon: readonly ["primary", "secondary", "tertiary", "positive", "warning", "negative", "neutral", "transparent"];
+};
+/**
+ * The allowed colors for the SolidButton and IconButton
+ */
+type SolidButtonColor = typeof ButtonColorUtil.solid[number];
+/**
+ * The allowed colors for the OutlineButton
+ */
+type OutlineButtonColor = typeof ButtonColorUtil.outline[number];
+/**
+ * The allowed colors for the TextButton
+ */
+type TextButtonColor = typeof ButtonColorUtil.text[number];
+/**
+ * The allowed colors for the IconButton
+ */
+type IconButtonColor = typeof IconButtonUtil.icon[number];
+/**
+ * The different sizes for a button
+ */
+type ButtonSizes = 'small' | 'medium' | 'large' | 'none';
+type IconButtonSize = 'tiny' | 'small' | 'medium' | 'large' | 'none';
+/**
+ * The shard properties between all button types
+ */
+type ButtonProps = ButtonHTMLAttributes<HTMLButtonElement> & {
+    /**
+     * @default 'medium'
+     */
+    size?: ButtonSizes;
+};
+declare const ButtonUtil: {
+    paddingMapping: Record<ButtonSizes, string>;
+    iconPaddingMapping: Record<IconButtonSize, string>;
+};
+type ButtonWithIconsProps = ButtonProps & {
+    startIcon?: ReactNode;
+    endIcon?: ReactNode;
+};
+type SolidButtonProps = ButtonWithIconsProps & {
+    color?: SolidButtonColor;
+};
+type OutlineButtonProps = ButtonWithIconsProps & {
+    color?: OutlineButtonColor;
+};
+type TextButtonProps = ButtonWithIconsProps & {
+    color?: TextButtonColor;
+    coloredHoverBackground?: boolean;
+};
+/**
+ * The shard properties between all button types
+ */
+type IconButtonProps = ButtonHTMLAttributes<HTMLButtonElement> & {
+    /**
+     * @default 'medium'
+     */
+    size?: IconButtonSize;
+    color?: IconButtonColor;
+};
+/**
+ * A button with a solid background and different sizes
+ */
+declare const SolidButton: React.ForwardRefExoticComponent<ButtonHTMLAttributes<HTMLButtonElement> & {
+    /**
+     * @default 'medium'
+     */
+    size?: ButtonSizes;
+} & {
+    startIcon?: ReactNode;
+    endIcon?: ReactNode;
+} & {
+    color?: SolidButtonColor;
+} & React.RefAttributes<HTMLButtonElement>>;
+/**
+ * A button with an outline border and different sizes
+ */
+declare const OutlineButton: ({ children, color, size, startIcon, endIcon, onClick, className, ...restProps }: OutlineButtonProps) => react_jsx_runtime.JSX.Element;
+/**
+ * A text that is a button that can have different sizes
+ */
+declare const TextButton: ({ children, color, size, startIcon, endIcon, onClick, coloredHoverBackground, className, ...restProps }: TextButtonProps) => react_jsx_runtime.JSX.Element;
+/**
+ * A button for icons with a solid background and different sizes
+ */
+declare const IconButton: React.ForwardRefExoticComponent<ButtonHTMLAttributes<HTMLButtonElement> & {
+    /**
+     * @default 'medium'
+     */
+    size?: IconButtonSize;
+    color?: IconButtonColor;
+} & 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, isAnimated, containerClassName, ...props }: PropsWithChildren<DialogProps>) => React.ReactPortal;
+
+type ConfirmDialogType = 'positive' | 'negative' | 'neutral' | 'primary';
+type ButtonOverwriteType = {
+    text?: string;
+    color?: SolidButtonColor;
+    disabled?: boolean;
+};
+type ConfirmDialogProps = Omit<DialogProps, 'onClose'> & {
+    isShowingDecline?: boolean;
+    requireAnswer?: boolean;
+    onCancel: () => void;
+    onConfirm: () => void;
+    onDecline?: () => void;
+    confirmType?: ConfirmDialogType;
+    /**
+     * Order: Cancel, Decline, Confirm
+     */
+    buttonOverwrites?: [ButtonOverwriteType, ButtonOverwriteType, ButtonOverwriteType];
+};
+/**
+ * A Dialog for asking the user for confirmation
+ */
+declare const ConfirmDialog: ({ children, onCancel, onConfirm, onDecline, confirmType, buttonOverwrites, className, ...restProps }: PropsWithChildren<ConfirmDialogProps>) => react_jsx_runtime.JSX.Element;
+
+type DiscardChangesDialogProps = Omit<ConfirmDialogProps, 'onDecline' | 'onConfirm' | 'buttonOverwrites' | 'titleElement' | 'description'> & {
+    isShowingDecline?: boolean;
+    requireAnswer?: boolean;
+    onCancel: () => void;
+    onSave: () => void;
+    onDontSave: () => void;
+    titleOverwrite?: ReactNode;
+    descriptionOverwrite?: ReactNode;
+};
+declare const DiscardChangesDialog: ({ children, onCancel, onSave, onDontSave, titleOverwrite, descriptionOverwrite, ...props }: PropsWithChildren<DiscardChangesDialogProps>) => react_jsx_runtime.JSX.Element;
+
+type UseDelayOptionsResolved = {
+    delay: number;
+    disabled: boolean;
+};
+type UseDelayOptions = Partial<UseDelayOptionsResolved>;
+declare function useDelay(options?: UseDelayOptions): {
+    restartTimer: (onDelayFinish: () => void) => void;
+    clearTimer: () => void;
+    hasActiveTimer: boolean;
+};
+
+type EditCompleteOptionsResolved = {
+    onBlur: boolean;
+    afterDelay: boolean;
+    allowEnterComplete?: boolean;
+} & Omit<UseDelayOptionsResolved, 'disabled'>;
+type EditCompleteOptions = Partial<EditCompleteOptionsResolved>;
+type InputProps = InputHTMLAttributes<HTMLInputElement> & {
+    invalid?: boolean;
+    onChangeText?: (text: string) => void;
+    onEditCompleted?: (text: string) => void;
+    editCompleteOptions?: EditCompleteOptions;
+    defaultStyle?: boolean;
+};
+/**
+ * A Component for inputting text or other information
+ *
+ * Its state is managed must be managed by the parent
+ */
+declare const Input: React__default.ForwardRefExoticComponent<InputHTMLAttributes<HTMLInputElement> & {
+    invalid?: boolean;
+    onChangeText?: (text: string) => void;
+    onEditCompleted?: (text: string) => void;
+    editCompleteOptions?: EditCompleteOptions;
+    defaultStyle?: boolean;
+} & React__default.RefAttributes<HTMLInputElement>>;
+/**
+ * A Component for inputting text or other information
+ *
+ * Its state is managed by the component itself
+ */
+declare const InputUncontrolled: ({ value, onChangeText, ...props }: InputProps) => react_jsx_runtime.JSX.Element;
+
+type InputModalProps = ConfirmDialogProps & {
+    inputs: InputProps[];
+};
+/**
+ * A modal for receiving multiple inputs
+ */
+declare const InputDialog: ({ inputs, buttonOverwrites, ...props }: InputModalProps) => react_jsx_runtime.JSX.Element;
+
+type LanguageDialogProps = Omit<DialogProps, 'titleElement' | 'description'> & PropsWithChildren<{
+    titleOverwrite?: ReactNode;
+    descriptionOverwrite?: ReactNode;
+}>;
+/**
+ * A Dialog for selecting the Language
+ *
+ * The State of open needs to be managed by the parent
+ */
+declare const LanguageDialog: ({ onClose, titleOverwrite, descriptionOverwrite, ...props }: LanguageDialogProps) => react_jsx_runtime.JSX.Element;
+
+type ThemeDialogProps = Omit<DialogProps, 'titleElement' | 'description'> & {
+    titleOverwrite?: ReactNode;
+    descriptionOverwrite?: ReactNode;
+};
+/**
+ * A Dialog for selecting the Theme
+ *
+ * The State of open needs to be managed by the parent
+ */
+declare const ThemeDialog: ({ onClose, titleOverwrite, descriptionOverwrite, ...props }: PropsWithChildren<ThemeDialogProps>) => react_jsx_runtime.JSX.Element;
+
+type BagFunction<T> = (bag: T) => ReactNode;
+type BagFunctionOrNode<T> = BagFunction<T> | ReactNode;
+type PropsWithBagFunction<T, P = unknown> = P & {
+    children?: BagFunction<T>;
+};
+type PropsWithBagFunctionOrChildren<T, P = unknown> = P & {
+    children?: BagFunctionOrNode<T>;
+};
+declare const BagFunctionUtil: {
+    resolve: <T>(children: BagFunctionOrNode<T>, bag: T) => ReactNode;
+};
+
+type LabelType = 'md' | 'lg';
+type LabelProps = LabelHTMLAttributes<HTMLLabelElement> & {
+    /** The size of the label */
+    size?: LabelType;
+};
+/**
+ * A Label component
+ */
+declare const Label: ({ children, size, className, ...props }: LabelProps) => react_jsx_runtime.JSX.Element;
+
+type ErrorShowBehaviour = 'always' | 'whenTouched';
+type FormElementHTMLProperties = Pick<HTMLAttributes<HTMLElement>, 'id' | 'aria-labelledby' | 'aria-describedby' | 'aria-disabled' | 'aria-invalid' | 'aria-errormessage' | 'aria-required'>;
+type FormElementStateProperties = {
+    invalid: boolean;
+    disabled: boolean;
+};
+type FormElementWrapperBag = FormElementHTMLProperties & FormElementStateProperties & {
+    required: boolean;
+    isShowingError: boolean;
+    setIsShowingError: (isShowingError?: boolean) => void;
+};
+type FormElementWrapperProps = {
+    children: BagFunction<FormElementWrapperBag>;
+    id?: string;
+    required?: boolean;
+    disabled?: boolean;
+    isShowingError?: boolean;
+    onIsShowingError?: (isTouched: boolean) => void;
+    label?: ReactNode;
+    labelProps?: Omit<LabelProps, 'children'>;
+    errorShowBehaviour?: ErrorShowBehaviour;
+    error?: ReactNode;
+    errorProps?: Omit<HTMLAttributes<HTMLParagraphElement>, 'children'>;
+    description?: ReactNode;
+    descriptionProps?: Omit<HTMLAttributes<HTMLParagraphElement>, 'children'>;
+    containerClassName?: string;
+};
+declare const FormElementWrapper: ({ children, id, required, disabled, isShowingError: initialIsShowingError, onIsShowingError, label, labelProps, errorShowBehaviour, error, errorProps, description, descriptionProps, containerClassName, }: FormElementWrapperProps) => react_jsx_runtime.JSX.Element;
+
+declare const avtarSizeList: readonly ["sm", "md", "lg", "xl"];
+type AvatarSize = typeof avtarSizeList[number];
+declare const AvatarUtil: {
+    avatarSizeMapping: Record<"sm" | "md" | "lg" | "xl", number>;
+    sizes: readonly ["sm", "md", "lg", "xl"];
+};
+type ImageConfig = {
+    avatarUrl: string;
+    alt: string;
+};
+type AvatarProps = {
+    image?: ImageConfig;
+    name?: string;
+    size?: AvatarSize;
+    fullyRounded?: boolean;
+    className?: string;
+};
+/**
+ * A component for showing a profile picture
+ */
+declare const Avatar: ({ image, name, size, fullyRounded, className }: AvatarProps) => react_jsx_runtime.JSX.Element;
+type AvatarGroupProps = {
+    avatars: Omit<AvatarProps, 'size' | 'fullyRounded'>[];
+    maxShownProfiles?: number;
+    showTotalNumber?: boolean;
+    size?: AvatarSize;
+    fullyRounded?: boolean;
+};
+/**
+ * A component for showing a group of Avatar's
+ */
+declare const AvatarGroup: ({ avatars, maxShownProfiles, showTotalNumber, size, fullyRounded }: AvatarGroupProps) => react_jsx_runtime.JSX.Element;
+
+type CircleProps = Omit<HTMLAttributes<HTMLDivElement>, 'children' | 'color'> & {
+    radius: number;
+    className?: string;
+};
+declare const Circle: ({ radius, className, style, ...restProps }: CircleProps) => react_jsx_runtime.JSX.Element;
+
+type HelpwaveProps = SVGProps<SVGSVGElement> & {
+    color?: string;
+    animate?: 'none' | 'loading' | 'pulse' | 'bounce';
+    size?: 'sm' | 'md' | 'lg';
+};
+/**
+ * The helpwave loading spinner based on the svg logo.
+ */
+declare const HelpwaveLogo: ({ color, size, animate, ...props }: HelpwaveProps) => react_jsx_runtime.JSX.Element;
+
+type RingProps = {
+    innerSize: number;
+    width: number;
+    className?: string;
+};
+declare const Ring: ({ innerSize, width, className, }: RingProps) => react_jsx_runtime.JSX.Element;
+type AnimatedRingProps = RingProps & {
+    fillAnimationDuration?: number;
+    repeating?: boolean;
+    onAnimationFinished?: () => void;
+    style?: CSSProperties;
+};
+declare const AnimatedRing: ({ innerSize, width, className, fillAnimationDuration, repeating, onAnimationFinished, style, }: AnimatedRingProps) => react_jsx_runtime.JSX.Element;
+type RingWaveProps = Omit<AnimatedRingProps, 'innerSize'> & {
+    startInnerSize: number;
+    endInnerSize: number;
+    style?: CSSProperties;
+};
+declare const RingWave: ({ startInnerSize, endInnerSize, width, className, fillAnimationDuration, repeating, onAnimationFinished, style }: RingWaveProps) => react_jsx_runtime.JSX.Element;
+type RadialRingsProps = {
+    circle1ClassName?: string;
+    circle2ClassName?: string;
+    circle3ClassName?: string;
+    waveWidth?: number;
+    waveBaseColor?: string;
+    sizeCircle1?: number;
+    sizeCircle2?: number;
+    sizeCircle3?: number;
+};
+declare const RadialRings: ({ circle1ClassName, circle2ClassName, circle3ClassName, waveWidth, waveBaseColor, sizeCircle1, sizeCircle2, sizeCircle3 }: RadialRingsProps) => react_jsx_runtime.JSX.Element;
+
+type TagProps = {
+    size?: number;
+    className?: string;
+};
+/**
+ * Tag icon from flaticon
+ *
+ * https://www.flaticon.com/free-icon/price-tag_721550?term=label&page=1&position=8&origin=tag&related_id=721550
+ *
+ * When using it make attribution
+ */
+declare const TagIcon: ({ className, size, }: TagProps) => react_jsx_runtime.JSX.Element;
+
+interface CarouselSlideProps extends HTMLAttributes<HTMLDivElement> {
+    isSelected: boolean;
+    index: number;
+}
+declare const CarouselSlide: React__default.ForwardRefExoticComponent<CarouselSlideProps & React__default.RefAttributes<HTMLDivElement>>;
+type CarouselProps = Omit<HTMLAttributes<HTMLDivElement>, 'children'> & {
+    children: ReactNode[];
+    animationTime?: number;
+    isLooping?: boolean;
+    isAutoPlaying?: boolean;
+    autoLoopingTimeOut?: number;
+    autoLoopAnimationTime?: number;
+    hintNext?: boolean;
+    arrows?: boolean;
+    dots?: boolean;
+    /**
+     * Percentage that is allowed to be scrolled further
+     */
+    overScrollThreshold?: number;
+    blurColor?: string;
+    heightClassName?: string;
+    slideClassName?: string;
+    slideContainerProps?: HTMLAttributes<HTMLDivElement>;
+    onSlideChanged?: (index: number) => void;
+};
+declare const Carousel: ({ children, animationTime, isLooping, isAutoPlaying, autoLoopingTimeOut, autoLoopAnimationTime, hintNext, arrows, dots, blurColor, heightClassName, slideClassName, slideContainerProps, onSlideChanged, ...props }: CarouselProps) => react_jsx_runtime.JSX.Element;
+
+declare const chipColors: readonly ["default", "dark", "red", "yellow", "green", "blue", "pink", "orange"];
+type ChipColor = typeof chipColors[number];
+type ChipVariant = 'normal' | 'fullyRounded';
+type ChipSize = 'sm' | 'md' | 'lg';
+declare const ChipUtil: {
+    colors: readonly ["default", "dark", "red", "yellow", "green", "blue", "pink", "orange"];
+};
+type ChipProps = HTMLAttributes<HTMLDivElement> & PropsWithChildren<{
+    color?: ChipColor;
+    size?: ChipSize;
+    icon?: boolean;
+    variant?: ChipVariant;
+    trailingIcon?: ReactNode;
+}>;
+/**
+ * A component for displaying a single chip
+ */
+declare const Chip: ({ children, trailingIcon, color, size, icon, variant, className, ...restProps }: ChipProps) => react_jsx_runtime.JSX.Element;
+type ChipListProps = {
+    list: ChipProps[];
+    className?: string;
+};
+/**
+ * A component for displaying a list of chips
+ */
+declare const ChipList: ({ list, className }: ChipListProps) => react_jsx_runtime.JSX.Element;
+
+type DividerInserterProps = Omit<HTMLAttributes<HTMLDivElement>, 'children'> & {
+    children: ReactNode[];
+    divider: (index: number) => ReactNode;
+};
+/**
+ * A Component for inserting a divider in the middle of each child element
+ *
+ *  undefined elements are removed
+ */
+declare const DividerInserter: ({ children, divider, className, ...restProps }: DividerInserterProps) => react_jsx_runtime.JSX.Element;
+
+type ExpansionIconProps = {
+    isExpanded?: boolean;
+    className?: string;
+};
+declare const ExpansionIcon: ({ isExpanded, className }: ExpansionIconProps) => react_jsx_runtime.JSX.Element;
+type IconBuilder = (expanded: boolean) => ReactNode;
+type ExpandableProps = PropsWithChildren<{
+    id?: string;
+    label: ReactNode;
+    icon?: IconBuilder;
+    isExpanded?: boolean;
+    onChange?: (isExpanded: boolean) => void;
+    /**
+     * Whether the expansion should only happen when the header is clicked or on the entire component
+     */
+    clickOnlyOnHeader?: boolean;
+    disabled?: boolean;
+    className?: string;
+    headerClassName?: string;
+    contentClassName?: string;
+    contentExpandedClassName?: string;
+}>;
+/**
+ * A Component for showing and hiding content
+ */
+declare const Expandable: React.ForwardRefExoticComponent<{
+    id?: string;
+    label: ReactNode;
+    icon?: IconBuilder;
+    isExpanded?: boolean;
+    onChange?: (isExpanded: boolean) => void;
+    /**
+     * Whether the expansion should only happen when the header is clicked or on the entire component
+     */
+    clickOnlyOnHeader?: boolean;
+    disabled?: boolean;
+    className?: string;
+    headerClassName?: string;
+    contentClassName?: string;
+    contentExpandedClassName?: string;
+} & {
+    children?: ReactNode | undefined;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const ExpandableUncontrolled: React.ForwardRefExoticComponent<{
+    id?: string;
+    label: ReactNode;
+    icon?: IconBuilder;
+    isExpanded?: boolean;
+    onChange?: (isExpanded: boolean) => void;
+    /**
+     * Whether the expansion should only happen when the header is clicked or on the entire component
+     */
+    clickOnlyOnHeader?: boolean;
+    disabled?: boolean;
+    className?: string;
+    headerClassName?: string;
+    contentClassName?: string;
+    contentExpandedClassName?: string;
+} & {
+    children?: ReactNode | undefined;
+} & React.RefAttributes<HTMLDivElement>>;
+
+type ContentType = {
+    type: 'markdown';
+    value: string;
+} | {
+    type: 'custom';
+    value: ReactNode;
+};
+type FAQItem = Pick<ExpandableProps, 'isExpanded' | 'className'> & {
+    id: string;
+    title: string;
+    content: ContentType;
+};
+type FAQSectionProps = {
+    entries: FAQItem[];
+    expandableClassName?: string;
+};
+/**
+ * Description
+ */
+declare const FAQSection: ({ entries, expandableClassName }: 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: MutableRefObject<HTMLElement>;
+    anchorRef: MutableRefObject<HTMLElement>;
+    windowRef?: MutableRefObject<HTMLElement>;
+    active?: boolean;
+};
+declare function useFloatingElement({ active, windowRef, anchorRef, containerRef, isPolling, pollingInterval, verticalAlignment, horizontalAlignment, screenPadding, gap, }: UseFloatingElementProps): CSSProperties;
+
+type FloatingContainerProps = HTMLAttributes<HTMLDivElement> & UseFloatingElementOptions & {
+    anchor?: MutableRefObject<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?: MutableRefObject<HTMLElement>;
+    /**
+     * Polls the position of the anchor every 100ms
+     *
+     * Use sparingly
+     */
+    backgroundOverlay?: ReactNode;
+} & React.RefAttributes<HTMLDivElement>>;
+
+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[];
+    onItemClicked?: (value: string) => void;
+    onSelectionChanged?: (value: string[]) => void;
+    isSelection?: boolean;
+    isMultiple?: boolean;
+    orientation?: ListBoxOrientation;
+};
+declare const ListBoxPrimitive: React__default.ForwardRefExoticComponent<HTMLAttributes<HTMLUListElement> & {
+    value?: 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 ListBoxMultipleUncontrolledProps = ListBoxMultipleProps;
+declare const ListBoxMultipleUncontrolled: ({ value: initialValue, onSelectionChanged, ...props }: ListBoxMultipleUncontrolledProps) => 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 ListBoxUncontrolledProps = ListBoxProps;
+declare const ListBoxUncontrolled: ({ value: initialValue, onSelectionChanged, ...props }: ListBoxUncontrolledProps) => react_jsx_runtime.JSX.Element;
+
+type ASTNodeModifierType = 'none' | 'italic' | 'bold' | 'underline' | 'font-space' | 'primary' | 'secondary' | 'warn' | 'positive' | 'negative';
+declare const astNodeInserterType: readonly ["helpwave", "newline"];
+type ASTNodeInserterType = typeof astNodeInserterType[number];
+type ASTNodeDefaultType = 'text';
+type ASTNode = {
+    type: ASTNodeModifierType;
+    children: ASTNode[];
+} | {
+    type: ASTNodeInserterType;
+} | {
+    type: ASTNodeDefaultType;
+    text: string;
+};
+type ASTNodeInterpreterProps = {
+    node: ASTNode;
+    isRoot?: boolean;
+    className?: string;
+};
+declare const ASTNodeInterpreter: ({ node, isRoot, className, }: ASTNodeInterpreterProps) => string | react_jsx_runtime.JSX.Element;
+type MarkdownInterpreterProps = {
+    text: string;
+    className?: string;
+};
+declare const MarkdownInterpreter: ({ text, className }: MarkdownInterpreterProps) => react_jsx_runtime.JSX.Element;
+
+type ScrollBarSize = 'sm' | 'md';
+type ScrollBarType = 'auto' | 'always' | 'scroll' | 'hover';
+type ScrollBarAxis = 'horizontal' | 'vertical' | 'both' | 'none';
+type ScrollAreaProps = Omit<ScrollAreaPrimitive.ScrollAreaProps, 'type'> & PropsWithChildren & {
+    scrollbarSize?: ScrollBarSize;
+    scrollbarType?: ScrollBarType;
+    scrollbarAxis?: ScrollBarAxis;
+};
+declare const ScrollArea: ({ children, scrollbarSize, scrollbarType, scrollbarAxis, className, ...props }: ScrollAreaProps) => react_jsx_runtime.JSX.Element;
+
+interface TabInfo {
+    label: string;
+}
+interface TabContextType {
+    active: string | null;
+    setActive: (id: string) => void;
+    register: (id: string, label: string) => void;
+    unregister: (id: string) => void;
+    tabs?: TabInfo[];
+}
+declare function useTabContext(): TabContextType;
+type TabViewProps = HTMLAttributes<HTMLDivElement> & {
+    outerDivProps?: HTMLAttributes<HTMLDivElement>;
+    children?: ReactNode;
+    onTabChanged?: (tabId: string) => void;
+    initialTabIndex?: number;
+};
+declare function TabView({ children, outerDivProps, onTabChanged, initialTabIndex, ...props }: TabViewProps): react_jsx_runtime.JSX.Element;
+type TabProps = HTMLAttributes<HTMLDivElement> & {
+    id?: string;
+    label: string;
+};
+declare function Tab({ id: customId, label, children, ...props }: TabProps): react_jsx_runtime.JSX.Element;
+
+type TextImageColor = 'primary' | 'secondary' | 'dark';
+type TextImageProps = {
+    title: string;
+    description: string;
+    imageUrl: string;
+    onShowMoreClicked?: () => void;
+    color?: TextImageColor;
+    badge?: string;
+    contentClassName?: string;
+    className?: string;
+};
+/**
+ * A Component for layering a Text upon an image
+ */
+declare const TextImage: ({ title, description, imageUrl, onShowMoreClicked, color, badge, contentClassName, className, }: TextImageProps) => react_jsx_runtime.JSX.Element;
+
+type VerticalDividerProps = {
+    width?: number;
+    height?: number;
+    strokeWidth?: number;
+    dashGap?: number;
+    dashLength?: number;
+};
+/**
+ * A Component for creating a vertical Divider
+ */
+declare const VerticalDivider: ({ width, height, strokeWidth, dashGap, dashLength, }: VerticalDividerProps) => react_jsx_runtime.JSX.Element;
+
+type ErrorComponentProps = {
+    errorText?: string;
+    classname?: string;
+};
+/**
+ * The Component to show when an error occurred
+ */
+declare const ErrorComponent: ({ errorText, classname }: ErrorComponentProps) => react_jsx_runtime.JSX.Element;
+
+type LoadingAndErrorComponentProps = PropsWithChildren<{
+    isLoading?: boolean;
+    hasError?: boolean;
+    loadingComponent?: ReactNode;
+    errorComponent?: ReactNode;
+    /**
+     * in milliseconds
+     */
+    minimumLoadingDuration?: number;
+    className?: string;
+}>;
+/**
+ * A Component that shows the Error and Loading animation, when appropriate and the children otherwise
+ */
+declare const LoadingAndErrorComponent: ({ children, isLoading, hasError, loadingComponent, errorComponent, minimumLoadingDuration, className }: LoadingAndErrorComponentProps) => string | number | boolean | react_jsx_runtime.JSX.Element | Iterable<ReactNode>;
+
+type LoadingAnimationProps = {
+    loadingText?: string;
+    classname?: string;
+};
+/**
+ * A Component to show when loading data
+ */
+declare const LoadingAnimation: ({ loadingText, classname }: LoadingAnimationProps) => react_jsx_runtime.JSX.Element;
+
+type LoadingButtonProps = {
+    isLoading?: boolean;
+} & SolidButtonProps;
+declare const LoadingButton: ({ isLoading, size, onClick, ...rest }: LoadingButtonProps) => react_jsx_runtime.JSX.Element;
+
+type LoadingComponentProps = {
+    className?: string;
+};
+declare const LoadingContainer: ({ className }: LoadingComponentProps) => react_jsx_runtime.JSX.Element;
+
+type ProgressIndicatorProps = {
+    progress: number;
+    strokeWidth?: number;
+    size?: keyof typeof sizeMapping;
+    direction?: 'clockwise' | 'counterclockwise';
+    rotation?: number;
+};
+declare const sizeMapping: {
+    small: number;
+    medium: number;
+    big: number;
+};
+/**
+ * A progress indicator
+ *
+ * Start rotation is 3 o'clock and fills counterclockwise
+ *
+ * Progress is given from 0 to 1
+ */
+declare const ProgressIndicator: ({ progress, strokeWidth, size, direction, rotation }: ProgressIndicatorProps) => react_jsx_runtime.JSX.Element;
+
+type Crumb = {
+    display: ReactNode;
+    link: string;
+};
+type BreadCrumbProps = {
+    crumbs: Crumb[];
+    linkClassName?: string;
+    containerClassName?: string;
+};
+/**
+ * A component for showing a hierarchical link structure with an independent link on each element
+ *
+ * e.g. Organizations/Ward/<id>
+ */
+declare const BreadCrumb: ({ crumbs, linkClassName, containerClassName }: BreadCrumbProps) => react_jsx_runtime.JSX.Element;
+
+type SimpleNavigationItem = {
+    label: ReactNode;
+    link: string;
+    external?: boolean;
+};
+type SubItemNavigationItem = {
+    label: ReactNode;
+    items?: SimpleNavigationItem[];
+};
+type NavigationItemType = SimpleNavigationItem | SubItemNavigationItem;
+type NavigationItemListProps = Omit<HTMLAttributes<HTMLElement>, 'children'> & {
+    items: NavigationItemType[];
+};
+declare const NavigationItemList: ({ items, ...restProps }: NavigationItemListProps) => react_jsx_runtime.JSX.Element;
+type NavigationProps = NavigationItemListProps;
+declare const Navigation: ({ ...props }: NavigationProps) => react_jsx_runtime.JSX.Element;
+
+type PaginationProps = {
+    pageIndex: number;
+    pageCount: number;
+    onPageChanged: (page: 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;
+
+type StepperState = {
+    currentStep: number;
+    seenSteps: Set<number>;
+};
+type StepperBarProps = {
+    state?: StepperState;
+    numberOfSteps: number;
+    disabledSteps?: Set<number>;
+    onChange: (state: StepperState) => void;
+    onFinish: () => void;
+    finishText?: string;
+    showDots?: boolean;
+    className?: string;
+};
+/**
+ * A Component for stepping
+ */
+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 PropertyBaseProps = {
+    name: string;
+    input: (props: {
+        softRequired: boolean;
+        hasValue: boolean;
+    }) => ReactNode;
+    onRemove?: () => void;
+    hasValue: boolean;
+    softRequired?: boolean;
+    readOnly?: boolean;
+    icon?: ReactNode;
+    className?: string;
+};
+/**
+ * A component for showing a properties with uniform styling
+ */
+declare const PropertyBase: ({ name, input, softRequired, hasValue, icon, readOnly, onRemove, className, }: PropertyBaseProps) => react_jsx_runtime.JSX.Element;
+
+type CheckboxPropertyProps = Omit<PropertyBaseProps, 'icon' | 'input' | 'hasValue' | 'onRemove'> & {
+    value?: boolean;
+    onChange?: (value: boolean) => void;
+};
+/**
+ * An Input component for a boolean values
+ */
+declare const CheckboxProperty: ({ value, onChange, readOnly, ...baseProps }: CheckboxPropertyProps) => react_jsx_runtime.JSX.Element;
+
+type DatePropertyProps = Omit<PropertyBaseProps, 'icon' | 'input' | 'hasValue'> & {
+    value?: Date;
+    onChange?: (date: Date) => void;
+    onEditComplete?: (value: Date) => void;
+    type?: 'dateTime' | 'date';
+};
+/**
+ * An Input for date properties
+ */
+declare const DateProperty: ({ value, onChange, onEditComplete, readOnly, type, ...baseProps }: DatePropertyProps) => react_jsx_runtime.JSX.Element;
+
+type MultiSelectPropertyProps = Omit<PropertyBaseProps, 'icon' | 'input' | 'hasValue' | 'className'> & PropsWithChildren<{
+    values: string[];
+    onValuesChanged?: (value: string[]) => void;
+}>;
+/**
+ * An Input for MultiSelect properties
+ */
+declare const MultiSelectProperty: ({ children, values, onValuesChanged, ...props }: MultiSelectPropertyProps) => react_jsx_runtime.JSX.Element;
+
+type NumberPropertyProps = Omit<PropertyBaseProps, 'icon' | 'input' | 'hasValue'> & {
+    value?: number;
+    suffix?: string;
+    onChange?: (value: number) => void;
+    onEditComplete?: (value: number) => void;
+};
+/**
+ * An Input for number properties
+ */
+declare const NumberProperty: ({ value, onChange, onRemove, onEditComplete, readOnly, suffix, ...baseProps }: NumberPropertyProps) => react_jsx_runtime.JSX.Element;
+
+type SingleSelectPropertyProps = Omit<PropertyBaseProps, 'icon' | 'input' | 'hasValue' | 'className'> & PropsWithChildren<{
+    value?: string;
+    onValueChanged?: (value: string) => void;
+    onAddNew?: (value: string) => void;
+    selectedDisplay?: (value: string) => ReactNode;
+}>;
+/**
+ * An Input for SingleSelect properties
+ */
+declare const SingleSelectProperty: ({ children, value, onValueChanged, selectedDisplay, ...props }: SingleSelectPropertyProps) => react_jsx_runtime.JSX.Element;
+
+type TextPropertyProps = Omit<PropertyBaseProps, 'icon' | 'input' | 'hasValue'> & {
+    value?: string;
+    onChange?: (value: string) => void;
+    onEditComplete?: (value: string) => void;
+};
+/**
+ * An Input for Text properties
+ */
+declare const TextProperty: ({ value, readOnly, onChange, onRemove, onEditComplete, ...baseProps }: TextPropertyProps) => react_jsx_runtime.JSX.Element;
+
+type FillerRowElementProps = {
+    className?: string;
+};
+declare const FillerRowElement: ({ className }: FillerRowElementProps) => react_jsx_runtime.JSX.Element;
+
+declare const TableFilters: {
+    dateRange: (row: any, columnId: any, filterValue: [Date | null, Date | null]) => boolean;
+};
+
+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;
+
+declare module '@tanstack/react-table' {
+    interface ColumnMeta<TData extends RowData, TValue> {
+        className?: string;
+        filterType?: TableFilterType;
+    }
+    interface TableMeta<TData> {
+        headerRowClassName?: TableFilterType;
+        bodyRowClassName?: string;
+    }
+    interface FilterFns {
+        dateRange: 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;
+    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, 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> & {
+    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;
+
+type TableCellProps = PropsWithChildren<{
+    className?: string;
+}>;
+declare const TableCell: ({ children, className, }: TableCellProps) => react_jsx_runtime.JSX.Element;
+
+type TableSortButtonProps = IconButtonProps & {
+    sortDirection: SortDirection | false;
+    invert?: boolean;
+};
+/**
+ * An Extension of the normal button that displays the sorting state right of the content
+ */
+declare const TableSortButton: ({ sortDirection, invert, color, className, ...buttonProps }: TableSortButtonProps) => react_jsx_runtime.JSX.Element;
+
+type CheckBoxSize = 'sm' | 'md' | 'lg';
+type CheckboxProps = Omit<CheckboxProps$1, 'checked' | 'onCheckedChange' | 'onChange'> & {
+    checked?: boolean;
+    indeterminate?: boolean;
+    onChange?: (checked: boolean) => void;
+    size?: CheckBoxSize;
+};
+/**
+ * A Tristate checkbox
+ *
+ * The state is managed by the parent
+ */
+declare const Checkbox: ({ disabled, checked, indeterminate, onChange, size, className, ...props }: CheckboxProps) => react_jsx_runtime.JSX.Element;
+type CheckboxUncontrolledProps = CheckboxProps;
+/**
+ * A Tristate checkbox
+ *
+ * The state is managed by this component
+ */
+declare const CheckboxUncontrolled: ({ checked: initialChecked, onChange, ...props }: CheckboxUncontrolledProps) => react_jsx_runtime.JSX.Element;
+
+type Position$1 = 'top' | 'bottom' | 'left' | 'right';
+type CopyToClipboardWrapperProps = PropsWithChildren<{
+    textToCopy: string;
+    /**
+     * Class names of additional styling properties for the tooltip
+     */
+    tooltipClassName?: string;
+    /**
+     * Class names of additional styling properties for the container from which the tooltip will be created
+     */
+    containerClassName?: string;
+    position?: Position$1;
+    zIndex?: number;
+}>;
+/**
+ * A Component for showing a tooltip when hovering over Content
+ * @param tooltip The tooltip to show can be a text or any ReactNode
+ * @param children The Content for which the tooltip should be created
+ * @param tooltipClassName Additional ClassNames for the Container of the tooltip
+ * @param containerClassName Additional ClassNames for the Container holding the content
+ * @param position The direction of the tooltip relative to the Container
+ * @param zIndex The z Index of the tooltip (you may require this when stacking modal)
+ * @constructor
+ */
+declare const CopyToClipboardWrapper: ({ children, textToCopy, tooltipClassName, containerClassName, position, zIndex, }: CopyToClipboardWrapperProps) => react_jsx_runtime.JSX.Element;
+
+type DateTimePickerMode = 'date' | 'time' | 'dateTime';
+type DateTimePickerProps = {
+    mode?: DateTimePickerMode;
+    value?: Date;
+    start?: Date;
+    end?: Date;
+    onChange?: (date: Date) => void;
+    onFinish?: (date: Date) => void;
+    onRemove?: () => void;
+    datePickerProps?: Omit<DatePickerProps, 'onChange' | 'value' | 'start' | 'end'>;
+    timePickerProps?: Omit<TimePickerProps, 'onChange' | 'time' | 'maxHeight'>;
+};
+/**
+ * A Component for picking a Date and Time
+ */
+declare const DateTimePicker: ({ value, start, end, mode, onFinish, onChange, onRemove, timePickerProps, datePickerProps, }: DateTimePickerProps) => 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;
+type MenuBag = {
+    isOpen: boolean;
+    disabled: boolean;
+    toggleOpen: () => void;
+    close: () => void;
+};
+type MenuProps<T> = PropsWithBagFunctionOrChildren<MenuBag> & {
+    trigger: (bag: MenuBag, ref: RefObject<T>) => 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: <T extends HTMLElement>({ trigger, children, alignmentHorizontal, alignmentVertical, showOnHover, disabled, menuClassName, }: MenuProps<T>) => react_jsx_runtime.JSX.Element;
+
+type ScrollPickerProps<T> = {
+    options: T[];
+    mapping: (value: T) => string;
+    selected?: T;
+    onChange?: (value: T) => void;
+    disabled?: boolean;
+};
+/**
+ * A component for picking an option by scrolling
+ */
+declare const ScrollPicker: <T>({ options, mapping, selected, onChange, disabled, }: ScrollPickerProps<T>) => react_jsx_runtime.JSX.Element;
+
+type SearchBarProps = InputProps & {
+    onSearch?: () => void;
+    disableOnSearch?: boolean;
+    containerClassName?: string;
+};
+declare const SearchBar: ({ placeholder, onSearch, disableOnSearch, containerClassName, ...inputProps }: SearchBarProps) => react_jsx_runtime.JSX.Element;
+
+type TextareaProps = Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, 'value'> & {
+    /** Inside the area */
+    value?: string;
+    invalid?: boolean;
+    onChangeText?: (text: string) => void;
+    onEditCompleted?: (text: string) => void;
+    saveDelayOptions?: UseDelayOptions;
+    defaultStyle?: boolean;
+};
+/**
+ * A Textarea component for inputting longer texts
+ *
+ * The State is managed by the parent
+ */
+declare const Textarea: React.ForwardRefExoticComponent<Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, "value"> & {
+    /** Inside the area */
+    value?: string;
+    invalid?: boolean;
+    onChangeText?: (text: string) => void;
+    onEditCompleted?: (text: string) => void;
+    saveDelayOptions?: UseDelayOptions;
+    defaultStyle?: boolean;
+} & React.RefAttributes<HTMLTextAreaElement>>;
+/**
+ * A Textarea component that is not controlled by its parent
+ */
+declare const TextareaUncontrolled: ({ value, onChangeText, ...props }: TextareaProps) => react_jsx_runtime.JSX.Element;
+type TextareaWithHeadlineProps = Omit<TextareaProps, 'defaultStyle'> & {
+    headline: ReactNode;
+    headlineProps: Omit<LabelProps, 'children'>;
+    containerClassName?: string;
+};
+declare const TextareaWithHeadline: ({ id, headline, headlineProps, disabled, className, containerClassName, ...props }: TextareaWithHeadlineProps) => react_jsx_runtime.JSX.Element;
+
+type Position = 'top' | 'bottom' | 'left' | 'right';
+type TooltipProps = PropsWithChildren<{
+    tooltip: ReactNode;
+    /**
+     * Number of milliseconds until the tooltip appears
+     *
+     * defaults to 1000ms
+     */
+    animationDelay?: number;
+    /**
+     * Class names of additional styling properties for the tooltip
+     */
+    tooltipClassName?: string;
+    /**
+     * Class names of additional styling properties for the container from which the tooltip will be created
+     */
+    containerClassName?: string;
+    position?: Position;
+    zIndex?: number;
+}>;
+/**
+ * A Component for showing a tooltip when hovering over Content
+ * @param tooltip The tooltip to show can be a text or any ReactNode
+ * @param children The Content for which the tooltip should be created
+ * @param animationDelay The delay before the tooltip appears
+ * @param tooltipClassName Additional ClassNames for the Container of the tooltip
+ * @param containerClassName Additional ClassNames for the Container holding the content
+ * @param position The direction of the tooltip relative to the Container
+ * @param zIndex The z Index of the tooltip (you may require this when stacking modal)
+ * @constructor
+ */
+declare const Tooltip: ({ tooltip, children, animationDelay, tooltipClassName, containerClassName, position, zIndex, }: TooltipProps) => react_jsx_runtime.JSX.Element;
+
+type InsideLabelInputProps = Omit<InputProps, 'aria-label' | 'aria-labelledby' | 'placeholder'> & {
+    label: ReactNode;
+};
+/**
+ * Text input component with a label inside the input that moves up when editing
+ *
+ * The State is managed by the parent
+ */
+declare const InsideLabelInput: React.ForwardRefExoticComponent<Omit<InputProps, "aria-label" | "aria-labelledby" | "placeholder"> & {
+    label: ReactNode;
+} & React.RefAttributes<HTMLInputElement>>;
+declare const InsideLabelInputUncontrolled: ({ value: initialValue, ...props }: InsideLabelInputProps) => react_jsx_runtime.JSX.Element;
+
+type ToggleableInputProps = Omit<InputProps, 'defaultStyle'> & {
+    initialState?: 'editing' | 'display';
+    editCompleteOptions?: Omit<EditCompleteOptions, 'allowEnterComplete'>;
+};
+/**
+ * A Text input component for inputting text. It changes appearance upon entering the edit mode and switches
+ * back to display mode on loss of focus or on enter
+ *
+ * The State is managed by the parent
+ */
+declare const ToggleableInput: React.ForwardRefExoticComponent<Omit<InputProps, "defaultStyle"> & {
+    initialState?: "editing" | "display";
+    editCompleteOptions?: Omit<EditCompleteOptions, "allowEnterComplete">;
+} & React.RefAttributes<HTMLInputElement>>;
+declare const ToggleableInputUncontrolled: ({ value: initialValue, onChangeText, ...restProps }: ToggleableInputProps) => react_jsx_runtime.JSX.Element;
+
+type SelectIconAppearance = 'left' | 'right' | 'none';
+type SelectRootProps = PropsWithChildren<{
+    id?: string;
+    value?: string;
+    onValueChanged?: (value: string) => void;
+    values?: string[];
+    onValuesChanged?: (value: string[]) => void;
+    isOpen?: boolean;
+    disabled?: boolean;
+    invalid?: boolean;
+    isMultiSelect?: boolean;
+    iconAppearance?: SelectIconAppearance;
+}>;
+declare const SelectRoot: ({ children, id, value, onValueChanged, values, onValuesChanged, isOpen, disabled, invalid, isMultiSelect, iconAppearance, }: SelectRootProps) => react_jsx_runtime.JSX.Element;
+type SelectOptionProps = Omit<HTMLAttributes<HTMLLIElement>, 'children'> & {
+    value: string;
+    disabled?: boolean;
+    iconAppearance?: SelectIconAppearance;
+    children?: ReactNode;
+};
+declare const SelectOption: React__default.ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLLIElement>, "children"> & {
+    value: string;
+    disabled?: boolean;
+    iconAppearance?: SelectIconAppearance;
+    children?: ReactNode;
+} & React__default.RefAttributes<HTMLLIElement>>;
+type SelectButtonProps = ButtonHTMLAttributes<HTMLButtonElement> & {
+    placeholder?: ReactNode;
+    selectedDisplay?: (value: string[]) => ReactNode;
+};
+declare const SelectButton: React__default.ForwardRefExoticComponent<ButtonHTMLAttributes<HTMLButtonElement> & {
+    placeholder?: ReactNode;
+    selectedDisplay?: (value: string[]) => ReactNode;
+} & React__default.RefAttributes<HTMLButtonElement>>;
+type SelectChipDisplayProps = HTMLAttributes<HTMLDivElement> & {
+    disabled?: boolean;
+    placeholder?: ReactNode;
+};
+declare const SelectChipDisplay: React__default.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
+    disabled?: boolean;
+    placeholder?: ReactNode;
+} & React__default.RefAttributes<HTMLDivElement>>;
+type Orientation = 'vertical' | 'horizontal';
+type SelectContentProps = HTMLAttributes<HTMLUListElement> & {
+    alignment?: Pick<UseFloatingElementOptions, 'gap' | 'horizontalAlignment' | 'verticalAlignment'>;
+    orientation?: Orientation;
+    containerClassName?: string;
+};
+declare const SelectContent: React__default.ForwardRefExoticComponent<HTMLAttributes<HTMLUListElement> & {
+    alignment?: Pick<UseFloatingElementOptions, "gap" | "horizontalAlignment" | "verticalAlignment">;
+    orientation?: Orientation;
+    containerClassName?: string;
+} & React__default.RefAttributes<HTMLUListElement>>;
+type SelectProps = Omit<SelectRootProps, 'isMultiSelect' | 'values' | 'onValuesChanged'> & {
+    contentPanelProps?: SelectContentProps;
+    buttonProps?: Omit<SelectButtonProps, 'selectedDisplay'> & {
+        selectedDisplay?: (value: string) => ReactNode;
+    };
+};
+declare const Select: React__default.ForwardRefExoticComponent<Omit<SelectRootProps, "values" | "onValuesChanged" | "isMultiSelect"> & {
+    contentPanelProps?: SelectContentProps;
+    buttonProps?: Omit<SelectButtonProps, "selectedDisplay"> & {
+        selectedDisplay?: (value: string) => ReactNode;
+    };
+} & React__default.RefAttributes<HTMLButtonElement>>;
+type SelectUncontrolledProps = SelectProps;
+declare const SelectUncontrolled: React__default.ForwardRefExoticComponent<Omit<SelectRootProps, "values" | "onValuesChanged" | "isMultiSelect"> & {
+    contentPanelProps?: SelectContentProps;
+    buttonProps?: Omit<SelectButtonProps, "selectedDisplay"> & {
+        selectedDisplay?: (value: string) => ReactNode;
+    };
+} & React__default.RefAttributes<HTMLButtonElement>>;
+type MultiSelectProps = Omit<SelectRootProps, 'isMultiSelect' | 'value' | 'onValueChanged'> & {
+    contentPanelProps?: SelectContentProps;
+    buttonProps?: SelectButtonProps;
+};
+declare const MultiSelect: React__default.ForwardRefExoticComponent<Omit<SelectRootProps, "value" | "onValueChanged" | "isMultiSelect"> & {
+    contentPanelProps?: SelectContentProps;
+    buttonProps?: SelectButtonProps;
+} & React__default.RefAttributes<HTMLButtonElement>>;
+type MultiSelectUncontrolledProps = MultiSelectProps;
+declare const MultiSelectUncontrolled: React__default.ForwardRefExoticComponent<Omit<SelectRootProps, "value" | "onValueChanged" | "isMultiSelect"> & {
+    contentPanelProps?: SelectContentProps;
+    buttonProps?: SelectButtonProps;
+} & React__default.RefAttributes<HTMLButtonElement>>;
+type MultiSelectChipDisplayProps = Omit<SelectRootProps, 'isMultiSelect' | 'value' | 'onValueChanged'> & {
+    contentPanelProps?: SelectContentProps;
+    chipDisplayProps?: SelectChipDisplayProps;
+};
+declare const MultiSelectChipDisplay: React__default.ForwardRefExoticComponent<Omit<SelectRootProps, "value" | "onValueChanged" | "isMultiSelect"> & {
+    contentPanelProps?: SelectContentProps;
+    chipDisplayProps?: SelectChipDisplayProps;
+} & React__default.RefAttributes<HTMLDivElement>>;
+type MultiSelectChipDisplayUncontrolledProps = MultiSelectChipDisplayProps;
+declare const MultiSelectChipDisplayUncontrolled: React__default.ForwardRefExoticComponent<Omit<SelectRootProps, "value" | "onValueChanged" | "isMultiSelect"> & {
+    contentPanelProps?: SelectContentProps;
+    chipDisplayProps?: SelectChipDisplayProps;
+} & React__default.RefAttributes<HTMLDivElement>>;
+
+type FocusTrapProps = HTMLAttributes<HTMLDivElement> & {
+    active?: boolean;
+    initialFocus?: MutableRefObject<HTMLElement>;
+    /**
+     * Whether to focus the first element when the initialFocus isn't provided
+     *
+     * Focuses the container instead
+     */
+    focusFirst?: boolean;
+};
+/**
+ * A wrapper for the useFocusTrap hook that directly renders it to a div
+ */
+declare const FocusTrap: React.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
+    active?: boolean;
+    initialFocus?: MutableRefObject<HTMLElement>;
+    /**
+     * Whether to focus the first element when the initialFocus isn't provided
+     *
+     * Focuses the container instead
+     */
+    focusFirst?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+
+type TransitionBag = {
+    isOpen: boolean;
+    isTransitioning: boolean;
+    isUsingReducedMotion: boolean;
+    data: {
+        [key: `data-${string}`]: string | undefined;
+    };
+    handlers: {
+        onTransitionEnd?: () => void;
+        onAnimationEnd?: () => void;
+        onTransitionCancel?: () => void;
+    };
+};
+type TransitionWrapperProps = PropsWithBagFunctionOrChildren<TransitionBag> & {
+    show: boolean;
+    includeAnimation?: boolean;
+};
+/**
+ * Only use when you have a transition happening
+ */
+declare function Transition({ children, show, includeAnimation, }: TransitionWrapperProps): React.ReactNode;
+
+declare const useFocusGuards: () => void;
+
+declare function useFocusManagement(): {
+    getFocusableElements: () => HTMLElement[];
+    getNextFocusElement: () => HTMLElement | undefined;
+    getPreviousFocusElement: () => HTMLElement | undefined;
+    focusNext: () => void;
+    focusPrevious: () => void;
+};
+
+declare const useFocusOnceVisible: (ref: MutableRefObject<HTMLElement>, disable?: boolean) => void;
+
+type UseFocusTrapProps = {
+    container: MutableRefObject<HTMLElement>;
+    active?: boolean;
+    initialFocus?: MutableRefObject<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 UseHoverStateProps = {
+    /**
+     * The delay after which the menu is closed in milliseconds
+     *
+     * default: 200ms
+     */
+    closingDelay: number;
+    /**
+     * Whether the hover state management should be disabled
+     *
+     * default: false
+     */
+    isDisabled: boolean;
+};
+type UseHoverStateReturnType = {
+    /**
+     * Whether the element is hovered
+     */
+    isHovered: boolean;
+    /**
+     * Function to change the current hover status
+     */
+    setIsHovered: Dispatch<SetStateAction<boolean>>;
+    /**
+     * Handlers to pass on to the component that should be hovered
+     */
+    handlers: {
+        onMouseEnter: () => void;
+        onMouseLeave: () => void;
+    };
+};
+/**
+ * @param props See UseHoverStateProps
+ *
+ * A react hook for managing the hover state of a component. The handlers provided should be
+ * forwarded to the component which should be hovered over
+ */
+declare const useHoverState: (props?: Partial<UseHoverStateProps> | undefined) => UseHoverStateReturnType;
+
+type SetValue<T> = Dispatch<SetStateAction<T>>;
+type UseLocalStorageResult<T> = {
+    value: T;
+    setValue: SetValue<T>;
+    deleteValue: () => void;
+};
+/**
+ * @param key Key under which to save the data
+ * @param backupValue Used if the storage is unavailable or no value is present
+ *
+ * The backup value will never be saved to the storage unless you explicitly
+ */
+declare const useLocalStorage: <T>(key: string, backupValue: T) => UseLocalStorageResult<T>;
+
+type OptionsResolved = {
+    type?: 'info' | 'error' | 'warning';
+};
+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 const useOverwritableState: <T>(initialValue?: T, onChange?: (value: T) => void) => [T, React__default.Dispatch<React__default.SetStateAction<T>>];
+
+declare const useRerender: () => React.DispatchWithoutAction;
+
+/**
+ * A hook that wraps the event listener attachment
+ *
+ * Make sure your callback is stable (doesn't change every render)
+ * This can easily be achieved by wrapping it in a useCallback() and using it inside the useResizeCallbackWrapper
+ *
+ * @param callback Called when the window resizes
+ */
+declare const useResizeCallbackWrapper: (callback: (event: UIEvent) => void) => 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;
+    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>>;
+};
+
+type ValidatorError = 'notEmpty' | 'invalidEmail' | 'tooLong' | 'tooShort' | 'outOfRangeString' | 'outOfRangeNumber' | 'outOfRangeSelectionItems' | 'tooFewSelectionItems' | 'tooManySelectionItems';
+type ValidatorResult = ValidatorError | undefined;
+declare const UseValidators: {
+    notEmpty: (value: unknown) => ValidatorResult;
+    length: (value: string | undefined, bounds: [number | undefined, number | undefined]) => ValidatorResult;
+    email: (value: string | undefined) => string;
+    selection: (value: unknown[], bounds: [number | undefined, number | undefined]) => ValidatorResult;
+};
+declare const useTranslatedValidators: () => {
+    notEmpty: (value: unknown) => string;
+    length: (value: string | undefined, length: [number | undefined, number | undefined]) => string;
+    email: (value: string) => string;
+    selection: (value: unknown[] | undefined, length: [number | undefined, number | undefined]) => string;
+};
+
+declare const hightideTranslationLocales: readonly ["de-DE", "en-US"];
+type HightideTranslationLocales = typeof hightideTranslationLocales[number];
+type HightideTranslationEntries = {
+    'add': string;
+    'age': string;
+    'all': string;
+    'apply': string;
+    'back': string;
+    'cancel': string;
+    'carousel': string;
+    'change': string;
+    'chooseLanguage': string;
+    'chooseSlide': string;
+    'chooseTheme': string;
+    'clear': string;
+    'click': string;
+    'clickToCopy': string;
+    'clickToSelect': string;
+    'close': string;
+    'confirm': string;
+    'copied': string;
+    'copy': string;
+    'create': string;
+    'decline': string;
+    'delete': string;
+    'discard': string;
+    'discardChanges': string;
+    'done': string;
+    'edit': string;
+    'endDate': string;
+    'enterText': string;
+    'entryDate': string;
+    'error': string;
+    'errorOccurred': string;
+    'exit': string;
+    'fieldRequiredError': string;
+    'filter': string;
+    'gender': (values: {
+        gender: string;
+    }) => string;
+    'goodToSeeYou': string;
+    'identifier': string;
+    'invalidEmail': string;
+    'invalidEmailError': string;
+    'language': string;
+    'less': string;
+    'loading': string;
+    'locale': string;
+    'max': string;
+    'maxLengthError': string;
+    'min': string;
+    'minLengthError': string;
+    'more': string;
+    'name': string;
+    'next': string;
+    'no': string;
+    'none': string;
+    'notEmpty': string;
+    'nothingFound': string;
+    'of': string;
+    'optional': string;
+    'outOfRangeNumber': (values: {
+        min: number;
+        max: number;
+    }) => string;
+    'outOfRangeSelectionItems': (values: {
+        min: number;
+        max: number;
+    }) => string;
+    'outOfRangeString': (values: {
+        min: number;
+        max: number;
+    }) => string;
+    'pleaseWait': string;
+    'previous': string;
+    'remove': string;
+    'required': string;
+    'reset': string;
+    'save': string;
+    'saved': string;
+    'search': string;
+    'select': string;
+    'selectOption': string;
+    'show': string;
+    'showLess': string;
+    'showMore': string;
+    'showSlide': (values: {
+        index: number;
+    }) => string;
+    'slide': string;
+    'slideNavigation': string;
+    'slideOf': (values: {
+        index: number;
+        length: number;
+    }) => string;
+    'startDate': string;
+    'street': string;
+    'submit': string;
+    'success': string;
+    'text': string;
+    'themeMode': (values: {
+        theme: string;
+    }) => string;
+    'themes': (values: {
+        count: number;
+    }) => string;
+    'time.ago': string;
+    'time.agoDays': (values: {
+        days: number;
+    }) => string;
+    'time.april': string;
+    'time.august': string;
+    'time.century': (values: {
+        count: number;
+    }) => string;
+    'time.day': (values: {
+        count: number;
+    }) => string;
+    'time.decade': (values: {
+        count: number;
+    }) => string;
+    'time.december': string;
+    'time.february': string;
+    'time.hour': (values: {
+        count: number;
+    }) => string;
+    'time.in': string;
+    'time.inDays': (values: {
+        days: number;
+    }) => string;
+    'time.january': string;
+    'time.july': string;
+    'time.june': string;
+    'time.march': string;
+    'time.may': string;
+    'time.microsecond': (values: {
+        count: number;
+    }) => string;
+    'time.millisecond': (values: {
+        count: number;
+    }) => string;
+    'time.minute': (values: {
+        count: number;
+    }) => string;
+    'time.month': (values: {
+        count: number;
+    }) => string;
+    'time.monthName': (values: {
+        month: string;
+    }) => string;
+    'time.nanosecond': (values: {
+        count: number;
+    }) => string;
+    'time.november': string;
+    'time.october': string;
+    'time.second': (values: {
+        count: number;
+    }) => string;
+    'time.september': string;
+    'time.today': string;
+    'time.tomorrow': string;
+    'time.year': (values: {
+        count: number;
+    }) => string;
+    'time.yesterday': string;
+    'tooFewSelectionItems': (values: {
+        min: number;
+    }) => string;
+    'tooLong': (values: {
+        max: number;
+    }) => string;
+    'tooManySelectionItems': (values: {
+        max: number;
+    }) => string;
+    'tooShort': (values: {
+        min: number;
+    }) => string;
+    'unsavedChanges': string;
+    'unsavedChangesSaveQuestion': string;
+    'update': string;
+    'value': string;
+    'welcome': string;
+    'yes': string;
+};
+declare const hightideTranslation: Translation<HightideTranslationLocales, Partial<HightideTranslationEntries>>;
+
+type LocaleContextValue = {
+    locale: HightideTranslationLocales;
+    setLocale: Dispatch<SetStateAction<HightideTranslationLocales>>;
+};
+declare const LocaleContext: React.Context<LocaleContextValue>;
+type LocaleWithSystem = HightideTranslationLocales | 'system';
+type LocaleProviderProps = {
+    locale?: LocaleWithSystem;
+    onChangedLocale?: (locale: HightideTranslationLocales) => void;
+};
+declare const LocaleProvider: ({ children, locale, onChangedLocale }: PropsWithChildren<LocaleProviderProps>) => react_jsx_runtime.JSX.Element;
+declare const useLocale: () => LocaleContextValue;
+declare const useLanguage: () => {
+    language: string;
+};
+
+type DeepPartial<T> = T extends string | number | boolean | bigint | symbol | null | undefined | Function ? T : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends Map<infer K, infer V> ? Map<DeepPartial<K>, DeepPartial<V>> : T extends Set<infer U> ? Set<DeepPartial<U>> : T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+type SuperSet<T, Base> = Base extends T ? T : never;
+type SingleOrArray<T> = T | T[];
+type Exact<T, U extends T> = U;
+
+/**
+ * Use for translations where you know that all values are ICU strings.
+ *
+ * This most likely is the case for Translations provided by a backend,
+ * for more dynamic and typesafe translation use useTranslation instead
+ */
+declare function useICUTranslation<L extends string, T extends Record<string, string>>(translations: Translation<L, T>[] | Translation<L, T>, locale: L): (key: string, values?: Record<string, object>) => string;
+type UseHidetideTranslationOverwrites = {
+    locale?: HightideTranslationLocales;
+};
+type HidetideTranslationExtension<L extends string, T extends TranslationEntries> = PartialTranslationExtension<L, HightideTranslationLocales, T, HightideTranslationEntries>;
+/**
+ * A wrapper for the useHightideTranslation to load and specify the translations for the library
+ */
+declare function useHightideTranslation<L extends string, T extends TranslationEntries>(extensions?: SingleOrArray<HidetideTranslationExtension<L, T>>, overwrites?: UseHidetideTranslationOverwrites): <K extends keyof HightideTranslationEntries | keyof T>(key: K, values?: (T & HightideTranslationEntries)[K] extends (...args: infer P) => unknown ? P[0] : never) => string;
+
+declare function localeToLanguage(locale: HightideTranslationLocales): string;
+/**
+ * A constant definition for holding data regarding languages
+ */
+declare const LocalizationUtil: {
+    locals: readonly ["de-DE", "en-US"];
+    localToLanguage: typeof localeToLanguage;
+    DEFAULT_LOCALE: "en-US";
+    languagesLocalNames: Record<"de-DE" | "en-US", string>;
+};
+
+declare const themes: readonly ["light", "dark", "system"];
+type ThemeType = typeof themes[number];
+type ResolvedTheme = Exclude<ThemeType, 'system'>;
+declare const ThemeUtil: {
+    themes: readonly ["light", "dark", "system"];
+};
+type ThemeContextType = {
+    theme: ThemeType;
+    resolvedTheme: ResolvedTheme;
+    setTheme: Dispatch<SetStateAction<ThemeType>>;
+};
+declare const ThemeContext: React.Context<ThemeContextType>;
+type ThemeProviderProps = {
+    /**
+     * Only set this if you want to control the theme yourself
+     */
+    theme?: ThemeType;
+};
+declare const ThemeProvider: ({ children, theme }: PropsWithChildren<ThemeProviderProps>) => react_jsx_runtime.JSX.Element;
+declare const useTheme: () => ThemeContextType;
+
+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;
+
+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];
+
+declare const clamp: (value: number, range?: [number, number]) => number;
+
+declare const noop: () => any;
+
+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 class StorageService {
+    private storage;
+    constructor(storage: Storage);
+    get<T>(key: string): T | null;
+    set<T>(key: string, value: T): void;
+    delete(key: string): void;
+    deleteAll(): void;
+}
+declare class LocalStorageService extends StorageService {
+    constructor();
+}
+declare class SessionStorageService extends StorageService {
+    constructor();
+}
+
+declare const writeToClipboard: (text: string) => Promise<void>;
+
+export { ASTNodeInterpreter, type ASTNodeInterpreterProps, AnimatedRing, type AnimatedRingProps, ArrayUtil, Avatar, AvatarGroup, type AvatarGroupProps, type AvatarProps, type AvatarSize, AvatarUtil, type BagFunction, type BagFunctionOrNode, BagFunctionUtil, BreadCrumb, ButtonColorUtil, 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 ColorMode, type ColorShadingValue, type Coloring, type ColoringStyle, ConfirmDialog, type ConfirmDialogProps, type ConfirmDialogType, CopyToClipboardWrapper, type CopyToClipboardWrapperProps, type Crumb, DatePicker, type DatePickerProps, DatePickerUncontrolled, DateProperty, type DatePropertyProps, DateTimePicker, type DateTimePickerMode, type DateTimePickerProps, DayPicker, type DayPickerProps, DayPickerUncontrolled, type DeepPartial, Dialog, type DialogPosition, type DialogProps, type Direction, DiscardChangesDialog, DividerInserter, type DividerInserterProps, type Duration, type EaseFunction, EaseFunctions, type EditCompleteOptions, type EditCompleteOptionsResolved, ErrorComponent, type ErrorComponentProps, type Exact, Expandable, type ExpandableProps, ExpandableUncontrolled, ExpansionIcon, type ExpansionIconProps, type FAQItem, FAQSection, type FAQSectionProps, FillerRowElement, type FillerRowElementProps, FloatingContainer, type FloatingContainerProps, type FloatingElementAlignment, FocusTrap, type FocusTrapProps, type FormElementStateProperties, FormElementWrapper, type FormElementWrapperProps, HelpwaveBadge, type HelpwaveBadgeProps, HelpwaveLogo, type HelpwaveProps, type HightideTranslationEntries, type HightideTranslationLocales, IconButton, type IconButtonColor, type IconButtonProps, IconButtonUtil, Input, InputDialog, type InputModalProps, type InputProps, InputUncontrolled, InsideLabelInput, InsideLabelInputUncontrolled, Label, type LabelProps, type LabelType, 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, LoadingButton, type LoadingComponentProps, LoadingContainer, LocalStorageService, LocaleContext, type LocaleContextValue, LocaleProvider, LocalizationUtil, LoopingArrayCalculator, MarkdownInterpreter, type MarkdownInterpreterProps, Menu, type MenuBag, MenuItem, type MenuItemProps, type MenuProps, type Month, MultiSearchWithMapping, MultiSelect, MultiSelectChipDisplay, type MultiSelectChipDisplayProps, MultiSelectChipDisplayUncontrolled, type MultiSelectChipDisplayUncontrolledProps, MultiSelectProperty, type MultiSelectPropertyProps, type MultiSelectProps, MultiSelectUncontrolled, type MultiSelectUncontrolledProps, MultiSubjectSearchWithMapping, Navigation, NavigationItemList, type NavigationItemListProps, type NavigationItemType, type NavigationProps, NumberProperty, type NumberPropertyProps, OutlineButton, type OutlineButtonColor, type OutlineButtonProps, Pagination, type PaginationProps, type PopoverHorizontalAlignment, type PopoverVerticalAlignment, ProgressIndicator, type ProgressIndicatorProps, PropertyBase, type PropertyBaseProps, type PropsWithBagFunction, type PropsWithBagFunctionOrChildren, RadialRings, type RadialRingsProps, type RangeOptions, type ResolvedTheme, Ring, type RingProps, RingWave, type RingWaveProps, ScrollArea, type ScrollAreaProps, type ScrollBarAxis, type ScrollBarSize, type ScrollBarType, ScrollPicker, type ScrollPickerProps, SearchBar, type SearchBarProps, Select, SelectButton, SelectChipDisplay, SelectContent, type SelectContentProps, SelectOption, type SelectOptionProps, type SelectProps, SelectRoot, type SelectRootProps, SelectUncontrolled, type SelectUncontrolledProps, SessionStorageService, type ShadedColors, SimpleSearch, SimpleSearchWithMapping, type SingleOrArray, SingleSelectProperty, type SingleSelectPropertyProps, SolidButton, type SolidButtonColor, type SolidButtonProps, StepperBar, type StepperBarProps, StepperBarUncontrolled, type StepperState, type SuperSet, Tab, type TabContextType, type TabInfo, 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, TextButton, type TextButtonColor, type TextButtonProps, TextImage, type TextImageProps, TextProperty, type TextPropertyProps, Textarea, type TextareaProps, TextareaUncontrolled, TextareaWithHeadline, type TextareaWithHeadlineProps, ThemeContext, ThemeDialog, ThemeProvider, type ThemeType, ThemeUtil, TimeDisplay, TimePicker, type TimePickerProps, TimePickerUncontrolled, ToggleableInput, ToggleableInputUncontrolled, Tooltip, type TooltipProps, Transition, type TransitionWrapperProps, type UseDelayOptions, type UseDelayOptionsResolved, type UseFloatingElementOptions, type UseFloatingElementProps, type UseFocusTrapProps, type UseSearchProps, UseValidators, type ValidatorError, type ValidatorResult, VerticalDivider, type VerticalDividerProps, type WeekDay, YearMonthPicker, type YearMonthPickerProps, YearMonthPickerUncontrolled, addDuration, builder, changeDuration, clamp, closestMatch, createLoopingList, createLoopingListWithIndex, equalDate, equalSizeGroups, formatDate, formatDateTime, generateShadingColors, getBetweenDuration, getDaysInMonth, getNeighbours, getWeeksForCalenderMonth, hightideTranslation, hightideTranslationLocales, isInTimeSpan, match, monthsList, noop, range, resolveSetState, shadingColorValues, subtractDuration, useDelay, useFloatingElement, useFocusGuards, useFocusManagement, useFocusOnceVisible, useFocusTrap, useHightideTranslation, useHoverState, useICUTranslation, useIsMounted, useLanguage, useLocalStorage, useLocale, useLogOnce, useOutsideClick, useOverwritableState, usePopoverPosition, useRerender, useResizeCallbackWrapper, useSearch, useTabContext, useTheme, useTranslatedValidators, validateEmail, weekDayList, writeToClipboard };