import * as react_jsx_runtime from 'react/jsx-runtime';
import * as react from 'react';
import react__default, { HTMLAttributes, SVGProps, ReactNode, ElementType, ComponentPropsWithoutRef, ImgHTMLAttributes, ButtonHTMLAttributes, AnchorHTMLAttributes, MouseEventHandler, PointerEventHandler, PropsWithChildren, RefObject, CSSProperties, Dispatch, SetStateAction, HTMLAttributeAnchorTarget, InputHTMLAttributes, ComponentProps, JSX, TableHTMLAttributes, Key, TextareaHTMLAttributes, LabelHTMLAttributes, ForwardedRef } from 'react';
import { Translation, TranslationEntries, PartialTranslationExtension } from '@helpwave/internationalization';
import { TableFeature, Table as Table$1, ColumnDef, TableState, RowModel, Row, InitialTableState, TableOptions, RowData, FilterFn, RowSelectionState, Header, SortDirection, ColumnSizingState, ColumnFilter, ColumnSort } from '@tanstack/react-table';
import { Virtualizer } from '@tanstack/react-virtual';

type Size$1 = 'sm' | 'md' | 'lg';
type AppZumDocBadgeProps = HTMLAttributes<HTMLSpanElement> & {
    size?: Size$1;
};
declare const AppZumDocBadge: ({ size, ...props }: AppZumDocBadgeProps) => react_jsx_runtime.JSX.Element;

type AppZumDocLogoProps = SVGProps<SVGSVGElement> & {
    frontColor?: string;
    backColor?: string;
    animate?: 'none' | 'loading' | 'pulse' | 'bounce';
    size?: 'sm' | 'md' | 'lg';
    animationDuration?: number;
};
declare const AppZumDocLogo: ({ frontColor, backColor, animate, size, animationDuration, ...props }: AppZumDocLogoProps) => react_jsx_runtime.JSX.Element;

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;

type HelpwaveProps = SVGProps<SVGSVGElement> & {
    color?: string;
    animate?: 'none' | 'loading' | 'pulse' | 'bounce';
    size?: 'sm' | 'md' | 'lg';
    animationDuration?: number;
};
/**
 * The helpwave loading spinner based on the svg logo.
 */
declare const HelpwaveLogo: ({ color, size, animate, animationDuration, ...props }: HelpwaveProps) => react_jsx_runtime.JSX.Element;

type ChatMessageDirection = 'incoming' | 'outgoing';
type ChatMessageBubbleProps = HTMLAttributes<HTMLDivElement> & {
    direction?: ChatMessageDirection;
    timestamp?: ReactNode;
    readReceipt?: ReactNode;
};
declare const ChatMessageBubble: ({ direction, timestamp, readReceipt, children, ...props }: ChatMessageBubbleProps) => react_jsx_runtime.JSX.Element;

type ChatAttachmentCardProps = HTMLAttributes<HTMLDivElement> & {
    name: ReactNode;
    metadata?: ReactNode;
    icon?: ReactNode;
    direction?: ChatMessageDirection;
    downloadLabel?: string;
    onDownload?: () => void;
};
declare const ChatAttachmentCard: ({ name, metadata, icon, direction, downloadLabel, onDownload, ...props }: ChatAttachmentCardProps) => react_jsx_runtime.JSX.Element;

type ScrollableListBaseProps = {
    header?: ReactNode;
    footer?: ReactNode;
    footerClassName?: string;
    headerClassName?: string;
    contentClassName?: string;
};
type ScrollableListProps<E extends ElementType = 'div'> = ScrollableListBaseProps & {
    as?: E;
} & Omit<ComponentPropsWithoutRef<E>, keyof ScrollableListBaseProps | 'as'>;
declare const ScrollableList: <E extends ElementType = "div">({ as, header, footer, footerClassName, headerClassName, contentClassName, className, children, ...props }: ScrollableListProps<E>) => react_jsx_runtime.JSX.Element;

type ChatConversationListProps = Omit<ScrollableListProps, 'as'>;
declare const ChatConversationList: ({ className, headerClassName, contentClassName, footerClassName, ...props }: ChatConversationListProps) => react_jsx_runtime.JSX.Element;

type AvatarSize = 'xs' | 'sm' | 'md' | 'lg' | null;
type ImageConfig = {
    avatarUrl: string;
    alt: string;
};
type AvatarImageProps = ImgHTMLAttributes<HTMLImageElement>;
type AvatarProps = Omit<HTMLAttributes<HTMLDivElement>, 'children'> & {
    image?: ImageConfig;
    name?: string;
    size?: AvatarSize;
    ImageComponent?: ElementType<AvatarImageProps>;
};
/**
 * A component for showing a profile picture
 */
declare const Avatar: ({ image: initialImage, name, size, ImageComponent, ...props }: AvatarProps) => react_jsx_runtime.JSX.Element;
type AvatarGroupProps = HTMLAttributes<HTMLDivElement> & {
    'avatars': Omit<AvatarProps, 'size'>[];
    'showTotalNumber'?: boolean;
    'size'?: AvatarSize;
    'data-name'?: string;
    'ImageComponent'?: ElementType<AvatarImageProps>;
};
/**
 * A component for showing a group of Avatar's
 */
declare const AvatarGroup: ({ avatars, showTotalNumber, size, ImageComponent, ...props }: AvatarGroupProps) => react_jsx_runtime.JSX.Element;
type AvatarStatus = 'online' | 'offline' | 'away' | 'busy' | 'unknown';
type AvatarWithStatusProps = AvatarProps & {
    status?: AvatarStatus;
};
declare const AvatarWithStatus: ({ status, className, size, ...avatarProps }: AvatarWithStatusProps) => react_jsx_runtime.JSX.Element;
type AvatarWithLabelPosition = 'left' | 'right';
type AvatarWithLabelProps = AvatarProps & {
    label: ReactNode;
    labelPosition?: AvatarWithLabelPosition;
};
/**
 * An avatar with a label displayed beside it
 */
declare const AvatarWithLabel: ({ label, labelPosition, className, size, ...avatarProps }: AvatarWithLabelProps) => react_jsx_runtime.JSX.Element;

type ChatConversationSentIndicator = 'sent' | 'sentAndReceived';
type ChatConversationRowProps = ButtonHTMLAttributes<HTMLButtonElement> & {
    avatar: AvatarWithStatusProps;
    title: ReactNode;
    timestamp?: ReactNode;
    preview?: ReactNode;
    unreadCount?: number;
    isSelected?: boolean;
    sentIndicator?: ChatConversationSentIndicator;
};
declare const ChatConversationRow: ({ avatar, title, timestamp, preview, unreadCount, isSelected, sentIndicator, ...props }: ChatConversationRowProps) => react_jsx_runtime.JSX.Element;

type ChatDateDividerProps = HTMLAttributes<HTMLDivElement>;
declare const ChatDateDivider: ({ children, ...props }: ChatDateDividerProps) => react_jsx_runtime.JSX.Element;

type ChipSize = 'xs' | 'sm' | 'md' | 'lg' | null;
type ChipColoringStyle = 'solid' | 'tonal' | 'outline' | 'tonal-outline' | null;
declare const chipColors: readonly ["primary", "secondary", "positive", "warning", "negative", "neutral"];
type ChipColor = typeof chipColors[number];
declare const ChipUtil: {
    colors: readonly ["primary", "secondary", "positive", "warning", "negative", "neutral"];
};
type ChipProps = HTMLAttributes<HTMLDivElement> & {
    color?: ChipColor;
    coloringStyle?: ChipColoringStyle;
    size?: ChipSize;
};
/**
 * A component for displaying a single chip
 */
declare const Chip: ({ children, color, coloringStyle, size, ...props }: ChipProps) => react_jsx_runtime.JSX.Element;
type ChipListProps = HTMLAttributes<HTMLUListElement> & {
    list: ChipProps[];
};
/**
 * A component for displaying a list of chips
 */
declare const ChipList: ({ list, ...props }: ChipListProps) => react_jsx_runtime.JSX.Element;

type ChatMessageCardProps = HTMLAttributes<HTMLDivElement> & {
    icon?: ReactNode;
    title: ReactNode;
    subtitle?: ReactNode;
    badge?: ReactNode;
    actions?: ReactNode;
    color?: ChipColor;
    direction?: ChatMessageDirection;
};
declare const ChatMessageCard: ({ icon, title, subtitle, badge, actions, color, direction, children, ...props }: ChatMessageCardProps) => react_jsx_runtime.JSX.Element;

type ChatMessageComposerProps = Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> & {
    value?: string;
    initialValue?: string;
    onValueChange?: (value: string) => void;
    onSend: (value: string) => void;
    placeholder?: string;
    sendLabel?: string;
    disabled?: boolean;
    actions?: ReactNode;
    trailing?: ReactNode;
};
declare const ChatMessageComposer: ({ value: controlledValue, initialValue, onValueChange, onSend, placeholder, sendLabel, disabled, actions, ...props }: ChatMessageComposerProps) => react_jsx_runtime.JSX.Element;

type ChatMessageListProps = HTMLAttributes<HTMLDivElement> & {
    autoScroll?: boolean;
};
declare const ChatMessageList: ({ autoScroll, children, ...props }: ChatMessageListProps) => react_jsx_runtime.JSX.Element;

type ChatQuickReplyChipProps = ButtonHTMLAttributes<HTMLButtonElement> & {
    isActive?: boolean;
};
declare const ChatQuickReplyChip: ({ isActive, children, ...props }: ChatQuickReplyChipProps) => react_jsx_runtime.JSX.Element;

type ChatSystemLineProps = HTMLAttributes<HTMLDivElement> & {
    icon?: ReactNode;
    color?: ChipColor;
};
declare const ChatSystemLine: ({ icon, color, children, ...props }: ChatSystemLineProps) => react_jsx_runtime.JSX.Element;

type ChatThreadHeaderProps = HTMLAttributes<HTMLDivElement> & {
    avatar?: AvatarWithStatusProps;
    title: ReactNode;
    subtitle?: ReactNode;
    leftActions?: ReactNode;
    rightActions?: ReactNode;
    leadingActionsClassName?: string;
    trailingActionsClassName?: string;
};
declare const ChatThreadHeader: ({ avatar, title, subtitle, leftActions, rightActions, leadingActionsClassName, trailingActionsClassName, ...props }: ChatThreadHeaderProps) => react_jsx_runtime.JSX.Element;

type CardSize = 'sm' | 'md' | 'lg';
type CardProps = Omit<HTMLAttributes<HTMLDivElement>, 'title'> & {
    title: ReactNode;
    description?: ReactNode;
    size?: CardSize;
    leading?: ReactNode;
    trailing?: ReactNode;
};
declare const Card: ({ title, description, size, leading, trailing, children, className, ...props }: CardProps) => react_jsx_runtime.JSX.Element;
type ActionCardProps = Omit<HTMLAttributes<HTMLDivElement>, 'title'> & {
    title: ReactNode;
    description?: ReactNode;
    size?: CardSize;
    leading?: ReactNode;
    trailing?: ReactNode;
    disabled?: boolean;
};
declare const ActionCard: react.ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDivElement>, "title"> & {
    title: ReactNode;
    description?: ReactNode;
    size?: CardSize;
    leading?: ReactNode;
    trailing?: ReactNode;
    disabled?: boolean;
} & react.RefAttributes<HTMLDivElement>>;
type NavigationCardLinkProps = AnchorHTMLAttributes<HTMLAnchorElement> & {
    href: string;
};
type NavigationCardProps = Omit<HTMLAttributes<HTMLAnchorElement>, 'title'> & {
    title: ReactNode;
    description?: ReactNode;
    size?: CardSize;
    leading?: ReactNode;
    href: string;
    isExternal?: boolean;
    LinkComponent?: ElementType<NavigationCardLinkProps>;
};
declare const NavigationCard: react.ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLAnchorElement>, "title"> & {
    title: ReactNode;
    description?: ReactNode;
    size?: CardSize;
    leading?: ReactNode;
    href: string;
    isExternal?: boolean;
    LinkComponent?: ElementType<NavigationCardLinkProps>;
} & react.RefAttributes<HTMLAnchorElement>>;

type Curve = (value: number) => number;
type ExponentialCurveBuilderPropsResolved = {
    basis: number;
    multiplier: number;
};
type ExponentialCurveBuilderProps = Partial<ExponentialCurveBuilderPropsResolved>;
type ExponentialRateCurveBuilder = (props: ExponentialCurveBuilderProps) => Curve;
type CubicBezierCurveBuilder = (x1: number, y1: number, x2: number, y2: number) => Curve;
declare const CurveBuilderUtil: {
    ExponentialRateCurveBuilder: ExponentialRateCurveBuilder;
    CubicBezierCurveBuilder: CubicBezierCurveBuilder;
    cubicBezierGeneric: (x1: number, y1: number, x2: number, y2: number) => {
        x: Curve;
        y: Curve;
    };
    easeInEaseOut: Curve;
};

type ChangingNumberProps = {
    start: number;
    end: number;
    animationTime?: number;
    curve?: Curve;
    resetRateAfterUpdate?: boolean;
    formatValue?: (value: number) => ReactNode;
};
/**
 * Displays a number animating from start to end along a curve over animationTime
 */
declare function ChangingNumber({ start, end, animationTime, curve, resetRateAfterUpdate, formatValue, }: ChangingNumberProps): ReactNode;

type ExpansionIconProps = HTMLAttributes<HTMLDivElement> & {
    isExpanded: boolean;
    disabled?: boolean;
};
declare const ExpansionIcon: ({ children, isExpanded, disabled, ...props }: ExpansionIconProps) => 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 ProcessModelActivityNodeKind = 'activity' | 'terminal';
type ProcessModelActivityNodeProps = {
    nodeId: string;
    label: string;
    count: string;
    customIcon: ReactNode;
    kind?: ProcessModelActivityNodeKind;
    bordered?: boolean;
    active?: boolean;
    visited?: boolean;
    className?: string;
    onClick?: MouseEventHandler<HTMLDivElement>;
    onPointerEnter?: PointerEventHandler<HTMLDivElement>;
    onPointerLeave?: PointerEventHandler<HTMLDivElement>;
};
declare const ProcessModelActivityNode: ({ nodeId, label, count, customIcon, kind, bordered, active, visited, className, onClick, onPointerEnter, onPointerLeave, }: ProcessModelActivityNodeProps) => react_jsx_runtime.JSX.Element;

type ProcessModelTerminalKind = 'start' | 'end';
type ProcessModelActivityIconKind = 'plus' | 'check';
type ProcessModelNodeBase = {
    id: string;
    label: string;
    count: string;
    layer: number;
    col: number;
};
type ProcessModelGraphTerminalNode = ProcessModelNodeBase & {
    type: ProcessModelTerminalKind;
};
type ProcessModelGraphActivityNode = ProcessModelNodeBase & {
    type: 'activity';
    activityIcon?: ProcessModelActivityIconKind;
};
type ProcessModelGraphNode = ProcessModelGraphTerminalNode | ProcessModelGraphActivityNode;
type ProcessModelEdge = {
    from: string;
    to: string;
    label: string;
    weight: number;
};
type ProcessModelTrace = {
    name: string;
    nodes: string[];
};
type ProcessModelGraph = {
    nodes: ProcessModelGraphNode[];
    edges: ProcessModelEdge[];
    traces?: ProcessModelTrace[];
};
type ProcessModelGraphWithTraces = ProcessModelGraph & {
    traces: ProcessModelTrace[];
};
type ProcessModelLibraryEntry = {
    id: string;
    name: string;
    description: string;
    graph: ProcessModelGraph;
};
type ProcessModelNodePosition = {
    x: number;
    y: number;
    w: number;
    h: number;
    layer: number;
};
type ProcessModelLayoutResult = {
    positions: Record<string, ProcessModelNodePosition>;
    canvasW: number;
    canvasH: number;
};
type ProcessModelEdgePointResult = {
    pathD: string;
    labelPt: {
        x: number;
        y: number;
    };
};
type ProcessModelEdgeStrokeStyle = {
    opacity: number;
    sw: number;
    markerTier: 'strong' | 'medium' | 'faint';
};

type ProcessModelCanvasProps = {
    graph: ProcessModelGraph;
    className?: string;
    showNodeBorder?: boolean;
    activeNodeId?: string;
    visitedNodeIds?: ReadonlySet<string>;
    renderActivityIcon?: (node: ProcessModelGraphActivityNode) => ReactNode;
    edgePathIdPrefix?: string;
    edgeReplayHighlight?: {
        from: string;
        to: string;
    } | null;
    replayParticle?: {
        cx: number;
        cy: number;
        opacity: number;
    } | null;
};
declare const ProcessModelCanvas: ({ graph, className, showNodeBorder, activeNodeId, visitedNodeIds, renderActivityIcon, edgePathIdPrefix, edgeReplayHighlight, replayParticle, }: ProcessModelCanvasProps) => react_jsx_runtime.JSX.Element;

type ProcessModelTerminalNodeProps = {
    nodeId: string;
    variant: ProcessModelTerminalKind;
    label: string;
    count: string;
    bordered?: boolean;
    active?: boolean;
    visited?: boolean;
    className?: string;
};
declare const ProcessModelTerminalNode: ({ nodeId, variant, label, count, bordered, active, visited, className, }: ProcessModelTerminalNodeProps) => react_jsx_runtime.JSX.Element;

type ProcessModelTraceReplayProps = {
    graph: ProcessModelGraphWithTraces;
    className?: string;
};
declare const ProcessModelTraceReplay: ({ graph, className }: ProcessModelTraceReplayProps) => react_jsx_runtime.JSX.Element;

declare function terminalCountDisplayLine(rawCount: string): string;
declare function estimateProcessModelActivityChromeWidth(kind: ProcessModelActivityNodeKind, label: string, countLine: string): number;
declare function estimateProcessModelActivityNodeWidth(label: string, count: string): number;
declare function computeLayout(graph: ProcessModelGraph): ProcessModelLayoutResult;
declare function getEdgePoints(pos: Record<string, ProcessModelNodePosition>, fromId: string, toId: string, allEdges: ProcessModelEdge[]): ProcessModelEdgePointResult | null;
declare function weightToStyle(weight: number, maxWeight: number): ProcessModelEdgeStrokeStyle;
declare function maxEdgeWeight(edges: ProcessModelEdge[]): number;
declare function getProcessModelEdgePathDomId(pathIdPrefix: string | undefined, from: string, to: string): string;
declare const ProcessModelLayoutUtilities: {
    ACTIVITY_NODE_MIN_WIDTH: number;
    NODE_H: number;
    terminalCountDisplayLine: typeof terminalCountDisplayLine;
    estimateProcessModelActivityChromeWidth: typeof estimateProcessModelActivityChromeWidth;
    estimateProcessModelActivityNodeWidth: typeof estimateProcessModelActivityNodeWidth;
    computeLayout: typeof computeLayout;
    getEdgePoints: typeof getEdgePoints;
    weightToStyle: typeof weightToStyle;
    maxEdgeWeight: typeof maxEdgeWeight;
    getProcessModelEdgePathDomId: typeof getProcessModelEdgePathDomId;
};

declare const processModelLibrary: ProcessModelLibraryEntry[];
declare function getProcessModelLibraryEntry(id: string): ProcessModelLibraryEntry | undefined;

type FormFieldAriaAttributes = Pick<HTMLAttributes<HTMLElement>, 'aria-labelledby' | 'aria-describedby' | 'aria-disabled' | 'aria-readonly' | 'aria-invalid' | 'aria-errormessage' | 'aria-required'>;
type FormFieldInteractionStates = {
    invalid: boolean;
    disabled: boolean;
    readOnly: boolean;
    required: boolean;
};
type FormFieldLayoutIds = {
    input: string;
    error: string;
    label: string;
    description: string;
};
type FormFieldLayoutBag = {
    interactionStates: FormFieldInteractionStates;
    ariaAttributes: FormFieldAriaAttributes;
    id: string;
};
type FormFieldLayoutProps = Omit<HTMLAttributes<HTMLDivElement>, 'children'> & Omit<Partial<FormFieldInteractionStates>, 'invalid'> & {
    children: (bag: FormFieldLayoutBag) => ReactNode;
    ids?: Partial<FormFieldLayoutIds>;
    label?: ReactNode;
    labelProps?: Omit<HTMLAttributes<HTMLLabelElement>, 'children' | 'id'>;
    invalidDescription?: ReactNode;
    invalidDescriptionProps?: Omit<HTMLAttributes<HTMLDivElement>, 'children' | 'id'>;
    description?: ReactNode;
    descriptionProps?: Omit<HTMLAttributes<HTMLParagraphElement>, 'children' | 'id'>;
    showRequiredIndicator?: boolean;
};
declare const FormFieldLayout: react.ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDivElement>, "children"> & Omit<Partial<FormFieldInteractionStates>, "invalid"> & {
    children: (bag: FormFieldLayoutBag) => ReactNode;
    ids?: Partial<FormFieldLayoutIds>;
    label?: ReactNode;
    labelProps?: Omit<HTMLAttributes<HTMLLabelElement>, "children" | "id">;
    invalidDescription?: ReactNode;
    invalidDescriptionProps?: Omit<HTMLAttributes<HTMLDivElement>, "children" | "id">;
    description?: ReactNode;
    descriptionProps?: Omit<HTMLAttributes<HTMLParagraphElement>, "children" | "id">;
    showRequiredIndicator?: boolean;
} & react.RefAttributes<HTMLDivElement>>;

type FormValidationBehaviour = 'always' | 'touched' | 'submit';
type FormValue = Record<string, any>;
type FormEvent<T extends FormValue> = {
    type: 'onSubmit';
    key: 'ALL';
    hasErrors: boolean;
    values: T;
    errors: Partial<Record<keyof T, ReactNode>>;
} | {
    type: 'reset';
    key: 'ALL';
    values: T;
    errors: Partial<Record<keyof T, ReactNode>>;
} | {
    type: 'onTouched';
    key: keyof T;
    value: T[keyof T];
    values: T;
} | {
    type: 'onUpdate';
    key: 'ALL';
    updatedKeys: (keyof T)[];
    update: Partial<T>;
    values: T;
    hasErrors: boolean;
    errors: Partial<Record<keyof T, ReactNode>>;
} | {
    type: 'onChange';
    key: keyof T;
    value: T[keyof T];
    values: T;
} | {
    type: 'onError';
    key: keyof T;
    value: T[keyof T];
    values: T;
    error: ReactNode;
};
type FormEventListener<T extends FormValue> = (event: FormEvent<T>) => void;
type FormValidator<T extends FormValue> = (value: T[keyof T]) => ReactNode;
type FormStoreProps<T extends FormValue> = {
    initialValues: T;
    hasTriedSubmitting?: boolean;
    submittingTouchesAll?: boolean;
    validators?: Partial<{
        [K in keyof T]: (v: T[K]) => ReactNode;
    }>;
};
declare class FormStore<T extends FormValue> {
    private values;
    private initialValues;
    private validators;
    private hasTriedSubmitting;
    private errors;
    private touched;
    private listeners;
    private submittingTouchesAll;
    constructor({ initialValues, hasTriedSubmitting, submittingTouchesAll, validators, }: FormStoreProps<T>);
    getValue<K extends keyof T>(key: K): T[K];
    getAllValues(): T;
    setValue<K extends keyof T>(key: K, value: T[K], triggerUpdate?: boolean): void;
    setValues(values: Partial<T>, triggerUpdate?: boolean): void;
    getTouched(key: keyof T): boolean;
    getAllTouched(): Partial<Record<keyof T, boolean>>;
    setTouched(key: keyof T, isTouched?: boolean): void;
    getHasError(): boolean;
    getErrors(): Partial<Record<keyof T, ReactNode>>;
    getError(key: keyof T): ReactNode;
    private setError;
    getHasTriedSubmitting(): boolean;
    changeValidators(validators: Partial<Record<keyof T, FormValidator<T>>>): void;
    validate(key: keyof T): void;
    validateAll(): void;
    subscribe(key: keyof T | 'ALL', listener: FormEventListener<T>): () => void;
    private notify;
    submit(): void;
    reset(): void;
}

type UseCreateFormProps<T extends FormValue> = Omit<FormStoreProps<T>, 'validationBehaviour'> & {
    onFormSubmit: (values: T) => void;
    onFormError?: (values: T, errors: Partial<Record<keyof T, ReactNode>>) => void;
    /**
     * Called when the form values change.
     *
     * E.g. a key press for an input field.
     *
     * For most purposes use {@link onUpdate} instead.
     * @param values The new values of the form.
     */
    onValueChange?: (values: T) => void;
    /**
     * Called when the form values change and the corresponding inputs determined that the user
     * finished editing these fields and the client should make an update against the server.
     *
     * E.g. a user finished editing an input field by pressing enter or blurring the field.
     *
     * @param updatedKeys The keys that were updated.
     * @param update The update that was made.
     */
    onValidUpdate?: (updatedKeys: (keyof T)[], update: Partial<T>) => void;
    /**
     * Called when the form values change and the corresponding inputs determined that the user
     * finished editing these fields and the client should make an update against the server.
     *
     * E.g. a user finished editing an input field by pressing enter or blurring the field.
     *
     * @param updatedKeys The keys that were updated.
     * @param update The update that was made.
     */
    onUpdate?: (updatedKeys: (keyof T)[], update: Partial<T>) => void;
    scrollToElements?: boolean;
    scrollOptions?: ScrollIntoViewOptions;
};
type UseCreateFormResult<T extends FormValue> = {
    /**
     * The form store.
     * Do not attempt to read the store directly, use useFormObserver or useFormField instead.
     * Otherwise you will not get the latest values and errors.
     */
    store: FormStore<T>;
    reset: () => void;
    submit: () => void;
    update: (updater: Partial<T> | ((current: T) => Partial<T>), triggerUpdate?: boolean) => void;
    validateAll: () => void;
    registerRef: (key: keyof T) => (el: HTMLElement | null) => void;
};
declare function useCreateForm<T extends FormValue>({ onFormSubmit, onFormError, onValueChange, onUpdate, onValidUpdate, initialValues, hasTriedSubmitting, validators, scrollToElements, scrollOptions, }: UseCreateFormProps<T>): UseCreateFormResult<T>;

type FormFieldFocusableElementProps = FormFieldAriaAttributes & {
    id: string;
    ref: (element: HTMLElement | null) => void;
};
type FormFieldBag<T extends FormValue, K extends keyof T> = {
    dataProps: FormFieldDataHandling<T[K]>;
    focusableElementProps: FormFieldFocusableElementProps;
    interactionStates: FormFieldInteractionStates;
    touched: boolean;
    other: {
        updateValue: (value: T[K]) => void;
    };
};
interface FormFieldProps<T extends FormValue, K extends keyof T> extends Omit<FormFieldLayoutProps, 'invalidDescription' | 'children'> {
    children: (bag: FormFieldBag<T, K>) => ReactNode;
    name: K;
    triggerUpdateOnEditComplete?: boolean;
    validationBehaviour?: FormValidationBehaviour;
}
type FormFieldDataHandling<T> = {
    value: T;
    onValueChange: (value: T) => void;
    onEditComplete: (value: T) => void;
};
declare const FormField: <T extends FormValue, K extends keyof T>({ children, name, triggerUpdateOnEditComplete, validationBehaviour, ...props }: FormFieldProps<T, K>) => react_jsx_runtime.JSX.Element;

type FormContextType<T extends FormValue> = UseCreateFormResult<T>;
declare const FormContext: react.Context<FormContextType<any>>;
type FormProviderProps<T extends FormValue> = PropsWithChildren & {
    state: FormContextType<T>;
};
declare const FormProvider: <T extends FormValue>({ children, state }: FormProviderProps<T>) => react_jsx_runtime.JSX.Element;
declare function useForm<T extends FormValue>(): FormContextType<T>;
interface UseFormFieldParameter<T extends FormValue> {
    key: keyof T;
}
interface UseFormFieldOptions {
    triggerUpdate?: boolean;
    validationBehaviour?: FormValidationBehaviour;
}
interface UserFormFieldProps<T extends FormValue> extends UseFormFieldParameter<T>, UseFormFieldOptions {
}
type FormFieldResult<T> = {
    store: FormStore<T>;
    value: T;
    error: ReactNode;
    touched: boolean;
    hasTriedSubmitting: boolean;
    dataProps: FormFieldDataHandling<T>;
    registerRef: (el: HTMLElement | null) => void;
};
declare function useFormField<T extends FormValue, K extends keyof T>(key: K, { triggerUpdate, validationBehaviour }: UseFormFieldOptions): FormFieldResult<T[K]> | null;
type UseFormObserverProps<T extends FormValue> = {
    formStore?: FormStore<T>;
};
interface FormObserverResult<T extends FormValue> {
    store: FormStore<T>;
    values: T;
    touched: Partial<Record<keyof T, boolean>>;
    errors: Partial<Record<keyof T, ReactNode>>;
    hasErrors: boolean;
    hasTriedSubmitting: boolean;
}
declare function useFormObserver<T extends FormValue>({ formStore }?: UseFormObserverProps<T>): FormObserverResult<T> | null;
interface UseFormObserverKeyProps<T extends FormValue, K extends keyof T> {
    formStore?: FormStore<T>;
    formKey: K;
}
interface FormObserverKeyResult<T extends FormValue, K extends keyof T> {
    store: FormStore<T>;
    value: T[K];
    error: ReactNode;
    hasError: boolean;
    touched: boolean;
}
declare function useFormObserverKey<T extends FormValue, K extends keyof T>({ formStore, formKey }: UseFormObserverKeyProps<T, K>): FormObserverKeyResult<T, K> | null;

interface FormObserverProps<T extends FormValue> extends UseFormObserverProps<T> {
    children: (bag: FormObserverResult<T>) => ReactNode;
}
declare const FormObserver: <T extends FormValue>({ children, formStore }: FormObserverProps<T>) => ReactNode;
interface FormObserverKeyProps<T extends FormValue, K extends keyof T> extends UseFormObserverKeyProps<T, K> {
    children: (bag: FormObserverKeyResult<T, K>) => ReactNode;
}
declare const FormObserverKey: <T extends FormValue, K extends keyof T>({ children, formStore, formKey }: FormObserverKeyProps<T, K>) => ReactNode;

type FloatingElementAlignment = 'beforeStart' | 'afterStart' | 'center' | 'beforeEnd' | 'afterEnd';
type CalculatePositionOptionsResolved = {
    verticalAlignment: FloatingElementAlignment;
    horizontalAlignment: FloatingElementAlignment;
    screenPadding: number;
    gap: number;
    avoidOverlap: boolean;
};
type CalculatePositionOptions = Partial<CalculatePositionOptionsResolved>;
type UseAnchoredPositionOptions = CalculatePositionOptions & {
    isPolling?: boolean;
    isReactingToResize?: boolean;
    isReactingToScroll?: boolean;
    pollingInterval?: number;
};
type UseAnchoredPostitionProps = UseAnchoredPositionOptions & {
    container: RefObject<HTMLElement | null>;
    anchor: RefObject<HTMLElement | null>;
    window?: RefObject<HTMLElement | null>;
    active?: boolean;
};
declare function useAnchoredPosition({ active, window: windowRef, anchor: anchorRef, container: containerRef, isPolling, isReactingToResize, isReactingToScroll, pollingInterval, verticalAlignment, horizontalAlignment, avoidOverlap, screenPadding, gap, }: UseAnchoredPostitionProps): CSSProperties;

type BackgroundOverlayProps = HTMLAttributes<HTMLDivElement>;
interface AnchoredFloatingContainerProps extends HTMLAttributes<HTMLDivElement> {
    anchor: RefObject<HTMLElement | null>;
    options?: UseAnchoredPositionOptions;
    active?: boolean;
}
declare const AnchoredFloatingContainer: react.ForwardRefExoticComponent<AnchoredFloatingContainerProps & react.RefAttributes<HTMLDivElement>>;

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;

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, ...restProps }: DividerInserterProps) => react_jsx_runtime.JSX.Element;

type ExpandableRootProps = HTMLAttributes<HTMLDivElement> & {
    'isExpanded'?: boolean;
    'onExpandedChange'?: (isExpanded: boolean) => void;
    'isInitialExpanded'?: boolean;
    'disabled'?: boolean;
    'allowContainerToggle'?: boolean;
    'data-name'?: string;
};
declare const ExpandableRoot: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
    isExpanded?: boolean;
    onExpandedChange?: (isExpanded: boolean) => void;
    isInitialExpanded?: boolean;
    disabled?: boolean;
    allowContainerToggle?: boolean;
    'data-name'?: string;
} & react.RefAttributes<HTMLDivElement>>;
type ExpandableHeaderProps = HTMLAttributes<HTMLDivElement> & {
    'isUsingDefaultIcon'?: boolean;
    'data-name'?: string;
};
declare const ExpandableHeader: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
    isUsingDefaultIcon?: boolean;
    'data-name'?: string;
} & react.RefAttributes<HTMLDivElement>>;
type ExpandableContentProps = HTMLAttributes<HTMLDivElement> & {
    'forceMount'?: boolean;
    'data-name'?: string;
};
declare const ExpandableContent: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
    forceMount?: boolean;
    'data-name'?: string;
} & react.RefAttributes<HTMLDivElement>>;
interface ExpandableProps extends ExpandableRootProps {
    trigger: ReactNode;
    triggerProps?: Omit<ExpandableHeaderProps, 'children'>;
    contentProps?: Omit<ExpandableContentProps, 'children'>;
    contentExpandedClassName?: string;
}
declare const Expandable: react.ForwardRefExoticComponent<ExpandableProps & react.RefAttributes<HTMLDivElement>>;

type FAQItem = Pick<ExpandableProps, 'isExpanded' | 'className'> & {
    title: string;
    content: ReactNode;
};
type FAQSectionProps = {
    entries: FAQItem[];
};
declare const FAQSection: ({ entries, }: FAQSectionProps) => react_jsx_runtime.JSX.Element;

interface InfiniteScrollProps {
    itemCount: number;
    /** How many items to keep in the DOM at once (default: 30) */
    bufferSize?: number;
    /** How many items to add tp the DOM when reaching one end at once (default: 7) */
    stepSize?: number;
    /** Pixels from edge to trigger a fetch/shift (default: 30) */
    scrollThreshold?: number;
    /** Initial index to center on or start at (optional) */
    initialIndex?: number;
    /** Render prop for each item */
    children: (index: number) => ReactNode;
    /** Optional classname for the scroll container */
    className?: string;
    /** Optional style for the container */
    style?: React.CSSProperties;
}
declare function InfiniteScroll({ children, itemCount, bufferSize, scrollThreshold, stepSize, initialIndex, className, style, }: InfiniteScrollProps): 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;

interface TabInfo {
    id: string;
    labelId: string;
    label: ReactNode;
    disabled?: boolean;
    ref: RefObject<HTMLElement | null>;
}
type PortalState = {
    id: string;
    ref: RefObject<HTMLElement | null>;
};
interface TabContextType {
    tabs: {
        activeId: string | null;
        setActiveId: Dispatch<SetStateAction<string | null>>;
        subscribe: (info: TabInfo) => () => void;
        infos: TabInfo[];
    };
    portal: {
        id: string | null;
        element: HTMLElement | null;
        setPortal: Dispatch<SetStateAction<PortalState | null>>;
    };
}
declare function useTabContext(): TabContextType;
interface TabSwitcherProps extends PropsWithChildren {
    activeId?: string;
    onActiveIdChange?: (activeId: string | null) => void;
    initialActiveId?: string;
}
/**
 * The controlling component of several Tabpanels.
 *
 * The uncontrolled mode only works if the Tabpanels do not remount.
 */
declare function TabSwitcher({ children, activeId: controlledActiveId, onActiveIdChange, initialActiveId }: TabSwitcherProps): react_jsx_runtime.JSX.Element;
type TabListProps = HTMLAttributes<HTMLUListElement>;
declare function TabList({ ...props }: TabListProps): react_jsx_runtime.JSX.Element;
type TabViewProps = HTMLAttributes<HTMLDivElement>;
declare function TabView({ ...props }: TabViewProps): react_jsx_runtime.JSX.Element;
type TabPanelProps = HTMLAttributes<HTMLDivElement> & {
    label: string;
    forceMount?: boolean;
    disabled?: boolean;
    initiallyActive?: boolean;
};
declare function TabPanel({ label, forceMount, disabled, initiallyActive, ...props }: TabPanelProps): 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 VisibilityProps = PropsWithChildren & {
    isVisible?: boolean;
};
declare function Visibility({ children, isVisible }: VisibilityProps): react_jsx_runtime.JSX.Element;

interface TreeNode {
    id: string;
    items: TreeNode[];
}
interface TreeItem {
    id: string;
    path: ReadonlyArray<string>;
    expanded: boolean;
}
interface TreeIndexEntry {
    node: TreeNode;
    parentId: string | null;
    path: string[];
}
interface TreeIndex {
    byId: Map<string, TreeIndexEntry>;
    roots: TreeNode[];
}

interface TreeExpansionOptions {
    nodes: ReadonlyArray<TreeNode>;
    onlyOneExpandedTree?: boolean;
    expandedIds?: ReadonlySet<string>;
    onExpandedIdsChange?: (expandedIds: ReadonlySet<string>) => void;
    initialExpandedIds?: ReadonlySet<string>;
    pruneCollapsedSubtrees?: boolean;
}
interface TreeExpansionActionOptions {
    focusedPath?: ReadonlyArray<string> | null;
    focusedId?: string | null;
}
interface TreeExpansionReturn {
    visibleItems: ReadonlyArray<TreeItem>;
    allItems: ReadonlyArray<TreeItem>;
    expandedIds: ReadonlySet<string>;
    setExpandedIds: react__default.Dispatch<react__default.SetStateAction<ReadonlySet<string>>>;
    expand: (id: string, options?: TreeExpansionActionOptions) => void;
    collapse: (id: string, options?: TreeExpansionActionOptions) => void;
    toggleExpansion: (id: string, options?: TreeExpansionActionOptions) => void;
    expandForPath: (path: ReadonlyArray<string>) => void;
}
declare function useTreeExpansion({ nodes, onlyOneExpandedTree, expandedIds: controlledExpandedIds, onExpandedIdsChange, initialExpandedIds, pruneCollapsedSubtrees, }: TreeExpansionOptions): TreeExpansionReturn;

interface NavigationItemState {
    expanded: boolean;
    isActive: boolean;
    isOnActivePath: boolean;
    path: ReadonlyArray<string>;
}
interface NavigationContextActions {
    toggleExpansion: ReturnType<typeof useTreeExpansion>['toggleExpansion'];
}
interface NavigationContextType extends NavigationContextActions {
    activeId: string | null;
    activePath: ReadonlyArray<string> | null;
    allItems: ReadonlyArray<TreeItem>;
    getItemState: (id: string) => NavigationItemState | null;
}
interface NavigationProviderProps extends TreeExpansionOptions {
    children: ReactNode;
    activeId?: string | null;
}
declare function NavigationProvider({ children, activeId, nodes, ...expansionOptions }: NavigationProviderProps): react_jsx_runtime.JSX.Element;
declare function useNavigationContext(): NavigationContextType;
declare function useNavigationItem(id: string): {
    toggleExpansion: (id: string, options?: TreeExpansionActionOptions) => void;
    expanded: boolean;
    isActive: boolean;
    isOnActivePath: boolean;
    path: ReadonlyArray<string>;
};

interface NavigationItemData {
    id: string;
    label: ReactNode;
    url?: string;
    external?: boolean;
    items?: NavigationItemData[];
}
declare function toTreeNodes(items: ReadonlyArray<NavigationItemData>): TreeNode[];

interface LinkComponentProps {
    'className'?: string;
    'href': string;
    'target'?: HTMLAttributeAnchorTarget | undefined;
    'rel'?: string | undefined;
    'aria-current'?: 'page' | undefined;
    'children'?: ReactNode;
}
interface VerticalNavigationMenuItemProps {
    id: string;
    label: NavigationItemData['label'];
    url?: string;
    external?: boolean;
    items?: NavigationItemData[];
    depth?: number;
    forceMountDepth?: number;
    LinkComponent?: ElementType<LinkComponentProps>;
}
declare function VerticalNavigationMenuItem({ id, label, url, external, items, depth, forceMountDepth, LinkComponent, }: VerticalNavigationMenuItemProps): react_jsx_runtime.JSX.Element;

interface VerticalNavigationMenuProps extends Omit<NavigationProviderProps, 'children' | 'nodes'> {
    items: NavigationItemData[];
    LinkComponent?: ElementType<LinkComponentProps>;
}
declare function VerticalNavigationMenu({ items, LinkComponent, ...navigationOptions }: VerticalNavigationMenuProps): react_jsx_runtime.JSX.Element;

interface AppSidebarProps extends HTMLAttributes<HTMLDivElement> {
    isOpen?: boolean;
    onClose?: () => void;
}
declare const AppSidebar: ({ isOpen, onClose, children, ...props }: AppSidebarProps) => react_jsx_runtime.JSX.Element;
interface AppPageSidebarWithNavigationProps extends AppSidebarProps {
    header?: ReactNode;
    footer?: ReactNode;
    navigationItems?: NavigationItemData[];
    contentOverwrite?: ReactNode;
    activeId?: string | null;
    LinkComponent?: ElementType<LinkComponentProps>;
}
declare const AppPageSidebarWithNavigation: ({ header, footer, navigationItems, contentOverwrite, activeId, LinkComponent, ...props }: AppPageSidebarWithNavigationProps) => react_jsx_runtime.JSX.Element;
interface AppPageNavigationItem {
    id: string;
    label: ReactNode;
    icon?: ReactNode;
    url?: string;
    external?: boolean;
    items?: AppPageNavigationItem[];
}
interface AppPageSidebarProps {
    activeId?: string | null;
    activeUrl?: string;
    header?: ReactNode;
    items?: AppPageNavigationItem[];
    contentOverwrite?: ReactNode;
    footer?: ReactNode;
    LinkComponent?: ElementType<LinkComponentProps>;
}
interface AppPageProps extends HTMLAttributes<HTMLDivElement> {
    headerActions?: ReactNode[];
    sidebarProps: AppPageSidebarProps;
    noScrolling?: boolean;
    hasSpacer?: boolean;
}
declare const AppPage: ({ children, headerActions, sidebarProps, noScrolling, hasSpacer, ...props }: AppPageProps) => react_jsx_runtime.JSX.Element;

type DialogPosition = 'top' | 'center' | 'none';
type DialogProps = HTMLAttributes<HTMLDivElement> & {
    /** Whether the dialog is currently open */
    isOpen?: boolean;
    /** Title of the Dialog used for accessibility */
    titleElement: ReactNode;
    /** Description of the Dialog used for accessibility */
    description: ReactNode;
    /** Callback when the dialog tries to close */
    onClose?: () => void;
    /** Styling for the background */
    backgroundClassName?: string;
    /** If true shows a close button and sends onClose on background clicks */
    isModal?: boolean;
    position?: DialogPosition;
    isAnimated?: boolean;
    containerClassName?: string;
};
/**
 * A generic dialog window which is managed by its parent
 */
declare const Dialog: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
    /** Whether the dialog is currently open */
    isOpen?: boolean;
    /** Title of the Dialog used for accessibility */
    titleElement: ReactNode;
    /** Description of the Dialog used for accessibility */
    description: ReactNode;
    /** Callback when the dialog tries to close */
    onClose?: () => void;
    /** Styling for the background */
    backgroundClassName?: string;
    /** If true shows a close button and sends onClose on background clicks */
    isModal?: boolean;
    position?: DialogPosition;
    isAnimated?: boolean;
    containerClassName?: string;
} & react.RefAttributes<HTMLDivElement>>;

type DialogContextType = {
    isOpen: boolean;
    setIsOpen: Dispatch<SetStateAction<boolean>>;
    isModal: boolean;
};
declare const DialogContext: react.Context<DialogContextType>;
declare function useDialogContext(): DialogContextType;

interface DialogOpenerWrapperBag {
    open: () => void;
    close: () => void;
    isOpen: boolean;
    toggleOpen: () => void;
    props: {
        'onClick': () => void;
        'aria-haspopup': 'dialog';
    };
}
interface DialogOpenerWrapperProps {
    children: (props: DialogOpenerWrapperBag) => ReactNode;
}
declare function DialogOpenerWrapper({ children }: DialogOpenerWrapperProps): ReactNode;
interface DialogOpenerPassingProps {
    'children'?: React.ReactNode;
    'onClick'?: React.MouseEventHandler<HTMLButtonElement>;
    'aria-haspopup'?: 'dialog';
}

interface DialogRootProps extends PropsWithChildren {
    isOpen?: boolean;
    onIsOpenChange?: (isOpen: boolean) => void;
    initialIsOpen?: boolean;
    isModal?: boolean;
}
declare function DialogRoot({ children, isOpen: controlledIsOpen, onIsOpenChange, initialIsOpen, isModal, }: DialogRootProps): react_jsx_runtime.JSX.Element;

/**
 * The different sizes for a button
 */
type ButtonSize = 'xs' | 'sm' | 'md' | 'lg' | null;
type ButtonColoringStyle = 'outline' | 'solid' | 'text' | 'tonal' | 'tonal-outline' | null;
declare const buttonColorsList: readonly ["primary", "secondary", "positive", "warning", "negative", "neutral"];
/**
 * The allowed colors for the Button
 */
type ButtonColor = typeof buttonColorsList[number] | null;
declare const ButtonUtil: {
    colors: readonly ["primary", "secondary", "positive", "warning", "negative", "neutral"];
};
/**
 * The shard properties between all button types
 */
type ButtonProps = ButtonHTMLAttributes<HTMLButtonElement> & {
    /**
     * @default 'medium'
     */
    size?: ButtonSize;
    color?: ButtonColor;
    /**
     * @default 'solid'
     */
    coloringStyle?: ButtonColoringStyle;
    allowClickEventPropagation?: boolean;
};
/**
 * A button with a solid background and different sizes
 */
declare const Button: react.ForwardRefExoticComponent<ButtonHTMLAttributes<HTMLButtonElement> & {
    /**
     * @default 'medium'
     */
    size?: ButtonSize;
    color?: ButtonColor;
    /**
     * @default 'solid'
     */
    coloringStyle?: ButtonColoringStyle;
    allowClickEventPropagation?: boolean;
} & react.RefAttributes<HTMLButtonElement>>;

type ConfirmDialogType = 'positive' | 'negative' | 'neutral' | 'primary';
type ButtonOverwriteType = {
    text?: string;
    color?: ButtonColor;
    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 = Omit<InputHTMLAttributes<HTMLInputElement>, 'value'> & Partial<FormFieldDataHandling<string>> & Partial<FormFieldInteractionStates> & {
    'editCompleteOptions'?: EditCompleteOptions;
    'initialValue'?: string;
    'data-name'?: string;
};
/**
 * A Component for inputting text or other information
 *
 * Its state is managed must be managed by the parent
 */
declare const Input: react__default.ForwardRefExoticComponent<Omit<InputHTMLAttributes<HTMLInputElement>, "value"> & Partial<FormFieldDataHandling<string>> & Partial<FormFieldInteractionStates> & {
    editCompleteOptions?: EditCompleteOptions;
    initialValue?: string;
    'data-name'?: string;
} & react__default.RefAttributes<HTMLInputElement>>;

type InputModalProps = ConfirmDialogProps & {
    inputs: InputProps[];
};
/**
 * A modal for receiving multiple inputs
 */
declare const InputDialog: ({ inputs, buttonOverwrites, ...props }: InputModalProps) => react_jsx_runtime.JSX.Element;

interface SelectIds {
    trigger: string;
    content: string;
    listbox: string;
    searchInput: string;
}
interface SelectRootProps<T> extends Partial<FormFieldDataHandling<T>>, Partial<FormFieldInteractionStates> {
    value?: T | null;
    initialValue?: T | null;
    compareFunction?: (a: T | null, b: T | null) => boolean;
    initialIsOpen?: boolean;
    onClose?: () => void;
    onIsOpenChange?: (isOpen: boolean) => void;
    showSearch?: boolean;
    iconAppearance?: 'left' | 'right' | 'none';
    children: ReactNode;
}
declare function SelectRoot<T>({ children, value, onValueChange, onEditComplete, initialValue, compareFunction, initialIsOpen, onClose, onIsOpenChange, showSearch, iconAppearance, invalid, disabled, readOnly, required, }: SelectRootProps<T>): react_jsx_runtime.JSX.Element;

interface UseSelectOption {
    id: string;
    label?: string;
    disabled?: boolean;
}
interface UseSelectOptions {
    options: ReadonlyArray<UseSelectOption>;
    value?: string | null;
    initialValue?: string | null;
    initialIsOpen?: boolean;
    onValueChange?: (value: string) => void;
    onEditComplete?: (value: string) => void;
    onClose?: () => void;
    onIsOpenChange?: (isOpen: boolean) => void;
    typeAheadResetMs?: number;
}
type UseSelectFirstHighlightBehavior = 'first' | 'last';
interface UseSelectState {
    value: string | null;
    highlightedValue: string | undefined;
    isOpen: boolean;
    searchQuery: string;
    options: ReadonlyArray<UseSelectOption>;
}
interface UseSelectComputedState {
    visibleOptionIds: ReadonlyArray<string>;
}
interface UseSelectActions {
    setIsOpen: (isOpen: boolean, behavior?: UseSelectFirstHighlightBehavior) => void;
    toggleOpen: (behavior?: UseSelectFirstHighlightBehavior) => void;
    setSearchQuery: (query: string) => void;
    highlightFirst: () => void;
    highlightLast: () => void;
    highlightNext: () => void;
    highlightPrevious: () => void;
    highlightItem: (value: string) => void;
    selectValue: (value: string) => void;
    handleTypeaheadKey: (key: string) => void;
}
interface UseSelectReturn extends UseSelectState, UseSelectComputedState, UseSelectActions {
}
declare function useSelect({ options, value: controlledValue, onValueChange, onEditComplete, initialValue, onClose, onIsOpenChange, initialIsOpen, typeAheadResetMs, }: UseSelectOptions): UseSelectReturn;

interface SelectOptionType<T = string> {
    id: string;
    value: T;
    label?: string;
    display?: ReactNode;
    disabled?: boolean;
    ref: RefObject<HTMLElement | null>;
}
interface SelectContextIds {
    trigger: string;
    content: string;
    listbox: string;
    searchInput: string;
}
interface SelectContextState<T> extends FormFieldInteractionStates {
    selectedId: string | null;
    options: ReadonlyArray<SelectOptionType<T>>;
    highlightedId: string | null;
    isOpen: boolean;
}
interface SelectContextComputedState<T> {
    visibleOptionIds: ReadonlyArray<string>;
    idToOptionMap: Record<string, SelectOptionType<T>>;
}
interface SelectContextActions<T> {
    registerOption(option: SelectOptionType<T>): () => void;
    toggleSelection(id: string): void;
    highlightFirst(): void;
    highlightLast(): void;
    highlightNext(): void;
    highlightPrevious(): void;
    highlightItem(id: string): void;
    handleTypeaheadKey(key: string): void;
    setIsOpen(open: boolean, behavior?: UseSelectFirstHighlightBehavior): void;
    toggleIsOpen(behavior?: UseSelectFirstHighlightBehavior): void;
}
interface SelectContextLayout {
    triggerRef: RefObject<HTMLElement | null>;
    registerTrigger(element: RefObject<HTMLElement | null>): () => void;
}
interface SelectContextSearch {
    hasSearch: boolean;
    searchQuery?: string;
    setSearchQuery(query: string): void;
}
type SelectIconAppearance = 'left' | 'right' | 'none';
interface SelectContextConfig {
    iconAppearance: SelectIconAppearance;
    ids: SelectContextIds;
    setIds: Dispatch<SetStateAction<SelectContextIds>>;
}
interface SelectContextType<T> extends SelectContextActions<T>, SelectContextState<T>, SelectContextComputedState<T> {
    config: SelectContextConfig;
    layout: SelectContextLayout;
    search: SelectContextSearch;
}
declare const SelectContext: react.Context<SelectContextType<unknown>>;
declare function useSelectContext<T>(): SelectContextType<T>;

interface SelectButtonProps<T = string> extends ComponentPropsWithoutRef<'div'> {
    'placeholder'?: ReactNode;
    'disabled'?: boolean;
    'selectedDisplay'?: (value: SelectOptionType<T> | null) => ReactNode;
    'hideExpansionIcon'?: boolean;
    'data-name'?: string;
}
declare const SelectButton: react.ForwardRefExoticComponent<SelectButtonProps<unknown> & react.RefAttributes<HTMLDivElement>>;

type UseFocusTrapProps = {
    container: RefObject<HTMLElement | null>;
    active: boolean;
    initialFocus?: RefObject<HTMLElement | null>;
};
declare const useFocusTrap: ({ container, active, initialFocus, }: UseFocusTrapProps) => void;

interface UseOutsideClickOptions {
    refs: RefObject<HTMLElement | null>[];
    active?: boolean;
}
interface UseOutsideClickHandlers {
    onOutsideClick: (event: MouseEvent | TouchEvent) => void;
}
interface UseOutsideClickProps extends UseOutsideClickOptions, UseOutsideClickHandlers {
}
declare const useOutsideClick: ({ refs, onOutsideClick, active }: UseOutsideClickProps) => void;

interface PopUpProps extends Omit<AnchoredFloatingContainerProps, 'anchor'>, Partial<UseOutsideClickHandlers> {
    'isOpen'?: boolean;
    'focusTrapOptions'?: Omit<UseFocusTrapProps, 'container'>;
    'outsideClickOptions'?: Partial<UseOutsideClickOptions>;
    'onClose'?: () => void;
    'forceMount'?: boolean;
    'anchorExcludedFromOutsideClick'?: boolean;
    'anchor'?: RefObject<HTMLElement | null>;
    'data-name'?: string;
}
declare const PopUp: react.ForwardRefExoticComponent<PopUpProps & react.RefAttributes<HTMLDivElement>>;

interface SelectContentProps extends PopUpProps {
    showSearch?: boolean;
    searchInputProps?: Omit<ComponentProps<typeof Input>, 'value' | 'onValueChange'>;
}
declare const SelectContent: react.ForwardRefExoticComponent<SelectContentProps & react.RefAttributes<HTMLUListElement>>;

type SelectProps<T = string> = SelectRootProps<T> & {
    contentPanelProps?: SelectContentProps;
    buttonProps?: Omit<SelectButtonProps<T>, 'selectedDisplay'> & {
        selectedDisplay?: (value: SelectOptionType<T> | null) => ReactNode;
    } & {
        [key: string]: unknown;
    };
};
declare const Select: <T>(props: SelectProps<T> & React.RefAttributes<HTMLDivElement>) => JSX.Element;

type LanguageSelectProps = Omit<SelectProps, 'value' | 'children'>;
declare const LanguageSelect: ({ ...props }: LanguageSelectProps) => react_jsx_runtime.JSX.Element;
type LanguageDialogProps = Omit<DialogProps, 'titleElement' | 'description'> & PropsWithChildren<{
    titleOverwrite?: ReactNode;
    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;

declare const hightideTranslationLocales: readonly ["de-DE", "en-US"];
type HightideTranslationLocales = typeof hightideTranslationLocales[number];
type HightideTranslationEntries = {
    'add': string;
    'addFilter': string;
    'addSorting': string;
    'addTime': string;
    'after': string;
    'age': string;
    'all': string;
    'apply': string;
    'back': string;
    'before': string;
    'between': string;
    'cancel': string;
    'carousel': string;
    'caseSensitive': string;
    'change': string;
    'changeColumnDisplay': string;
    'changePinning': string;
    'changeSelection': string;
    'changeVisibility': string;
    'chooseLanguage': string;
    'chooseSlide': string;
    'chooseTheme': string;
    'clear': string;
    'clearValue': string;
    'click': string;
    'clickToCopy': string;
    'clickToSelect': string;
    'close': string;
    'closeDialog': string;
    'columnPicker': string;
    'columnPickerDescription': string;
    'columns': string;
    'confirm': string;
    'contains': string;
    'copied': string;
    'copy': string;
    'create': string;
    'date': string;
    'dayPeriod': string;
    'decline': string;
    'decreaseSortingPriority': string;
    'decreaseValue': string;
    'delete': string;
    'discard': string;
    'discardChanges': string;
    'done': string;
    'edit': string;
    'editFilter': string;
    'endDate': string;
    'endsWith': string;
    'enterText': string;
    'entriesPerPage': string;
    'entryDate': string;
    'equals': string;
    'error': string;
    'errorOccurred': string;
    'exit': string;
    'fieldRequiredError': string;
    'filter': string;
    'filterNonWhitespace': string;
    'filterNotUndefined': string;
    'filterOptions': string;
    'filterUndefined': string;
    'first': string;
    'goodToSeeYou': string;
    'greaterThan': string;
    'greaterThanOrEqual': string;
    'hideAllColumns': string;
    'hideColumn': string;
    'identifier': string;
    'increaseSortingPriority': string;
    'increaseValue': string;
    'invalidEmail': string;
    'invalidEmailError': string;
    'isFalse': string;
    'isNotUndefined': string;
    'isTrue': string;
    'isUndefined': string;
    'language': string;
    'last': string;
    'less': string;
    'lessThan': string;
    'lessThanOrEqual': string;
    'loading': string;
    'locale': string;
    'max': string;
    'maxLengthError': string;
    'menu': string;
    'min': string;
    'minLengthError': string;
    'more': string;
    'moveDown': string;
    'moveUp': string;
    'name': string;
    'next': string;
    'no': string;
    'noColumn': string;
    'noData': string;
    'none': string;
    'noParameterRequired': string;
    'notBetween': string;
    'notContains': string;
    'notEmpty': string;
    'notEquals': string;
    'nothingFound': string;
    'nResultsFound': (values: {
        count: number;
    }) => string;
    'of': string;
    'onOrAfter': string;
    'onOrBefore': string;
    'optional': string;
    'outOfRangeNumber': (values: {
        min: number;
        max: number;
    }) => string;
    'outOfRangeSelectionItems': (values: {
        min: number;
        max: number;
    }) => string;
    'outOfRangeString': (values: {
        min: number;
        max: number;
    }) => string;
    'parameter': string;
    'pauseTrace': string;
    'pinLeft': string;
    'pinned': string;
    'pinRight': string;
    'pinToLeft': string;
    'pinToRight': string;
    'playTrace': string;
    'pleaseWait': string;
    'previous': string;
    'pThemes': (values: {
        count: number;
    }) => string;
    'rBetween': (values: {
        value1: string;
        value2: string;
    }) => string;
    'rContains': (values: {
        value: string;
    }) => string;
    'remove': string;
    'removeFilter': string;
    'removeProperty': string;
    'rEndsWith': (values: {
        value: string;
    }) => string;
    'rEquals': (values: {
        value: string;
    }) => string;
    'required': string;
    'reset': string;
    'rGreaterThan': (values: {
        value: string;
    }) => string;
    'rGreaterThanOrEqual': (values: {
        value: string;
    }) => string;
    'rLessThan': (values: {
        value: string;
    }) => string;
    'rLessThanOrEqual': (values: {
        value: string;
    }) => string;
    'rNotBetween': (values: {
        value1: string;
        value2: string;
    }) => string;
    'rNotContains': (values: {
        value: string;
    }) => string;
    'rNotEquals': (values: {
        value: string;
    }) => string;
    'rSortingOrderAfter': (values: {
        otherSortings: number;
    }) => string;
    'rStartsWith': (values: {
        value: string;
    }) => string;
    'save': string;
    'saved': string;
    'sDateTimeSelect': (values: {
        datetimeMode: string;
    }) => string;
    'search': string;
    'searchResults': string;
    'select': string;
    'selection': string;
    'selectOption': string;
    'sGender': (values: {
        gender: string;
    }) => string;
    'show': string;
    'showAllColumns': string;
    'showColumn': string;
    'showLess': string;
    'showMore': string;
    'showSlide': (values: {
        index: number;
    }) => string;
    'slide': string;
    'slideNavigation': string;
    'slideOf': (values: {
        index: number;
        length: number;
    }) => string;
    'sortAsc': string;
    'sortDesc': string;
    'sorting': string;
    'speed': string;
    'sSortingState': (values: {
        sortDirection: string;
    }) => string;
    'startDate': string;
    'startsWith': string;
    'sThemeMode': (values: {
        theme: string;
    }) => string;
    'street': string;
    'submit': string;
    'success': string;
    'tag': string;
    'tags': string;
    'text': string;
    'time.ago': string;
    'time.agoDays': (values: {
        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.nanosecond': (values: {
        count: number;
    }) => string;
    'time.nextMonth': string;
    'time.november': string;
    'time.october': string;
    'time.previousMonth': string;
    'time.second': (values: {
        count: number;
    }) => string;
    'time.september': string;
    'time.sMonthName': (values: {
        month: string;
    }) => 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;
    'unknown': string;
    'unpin': string;
    'unsavedChanges': string;
    'unsavedChangesSaveQuestion': string;
    'update': string;
    'value': string;
    'welcome': string;
    'withoutTime': string;
    'yes': string;
};
declare const hightideTranslation: Translation<HightideTranslationLocales, Partial<HightideTranslationEntries>>;

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;

type TooltipConfig = {
    appearDelay: number;
    isAnimated: boolean;
    screenPadding: number;
};
type ThemeConfig = {
    initialTheme: ResolvedTheme;
};
type LocalizationConfig = {
    defaultLocale: HightideTranslationLocales;
    defaultTimeZone?: string;
    defaultIs24HourFormat?: boolean;
};
type HightideConfig = {
    tooltip: TooltipConfig;
    theme: ThemeConfig;
    locale: LocalizationConfig;
};
type ConfigType = {
    config: HightideConfig;
    setConfig: (configOverwrite: DeepPartial<HightideConfig>) => void;
};
declare const HightideConfigContext: react.Context<ConfigType>;
type HightideConfigProviderProps = PropsWithChildren & DeepPartial<HightideConfig>;
declare const HightideConfigProvider: ({ children, ...initialOverwrite }: HightideConfigProviderProps) => react_jsx_runtime.JSX.Element;
declare const useHightideConfig: () => ConfigType;

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 = PropsWithChildren & Partial<ThemeConfig> & {
    /**
     * Only set this if you want to control the theme yourself
     */
    theme?: ThemeType;
};
declare const ThemeProvider: ({ children, theme, initialTheme }: ThemeProviderProps) => react_jsx_runtime.JSX.Element;
declare const useTheme: () => ThemeContextType;

interface ThemeIconProps extends HTMLAttributes<SVGSVGElement> {
    theme?: ThemeType;
}
declare const ThemeIcon: ({ theme: themeOverride, ...props }: ThemeIconProps) => react_jsx_runtime.JSX.Element;
type ThemeSelectProps = Omit<SelectProps<ThemeType>, 'value' | 'children'>;
declare const ThemeSelect: ({ ...props }: ThemeSelectProps) => react_jsx_runtime.JSX.Element;
interface ThemeDialogProps extends Omit<DialogProps, 'titleElement' | 'description'> {
    titleOverwrite?: ReactNode;
    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 DrawerAligment = 'left' | 'right' | 'bottom' | 'top';
type DrawerProps = HTMLAttributes<HTMLDivElement> & {
    isOpen: boolean;
    alignment: DrawerAligment;
    titleElement: ReactNode;
    description: ReactNode;
    headerOverwrite?: ReactNode;
    footer?: ReactNode;
    isAnimated?: boolean;
    containerClassName?: string;
    backgroundClassName?: string;
    onClose: () => void;
    forceMount?: boolean;
    hasDefaultCloseIcon?: boolean;
    noScrolling?: boolean;
};
declare const Drawer: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
    isOpen: boolean;
    alignment: DrawerAligment;
    titleElement: ReactNode;
    description: ReactNode;
    headerOverwrite?: ReactNode;
    footer?: ReactNode;
    isAnimated?: boolean;
    containerClassName?: string;
    backgroundClassName?: string;
    onClose: () => void;
    forceMount?: boolean;
    hasDefaultCloseIcon?: boolean;
    noScrolling?: boolean;
} & react.RefAttributes<HTMLDivElement>>;

interface TooltipTriggerContextValue {
    ref: RefObject<HTMLElement | null>;
    callbackRef: (el: HTMLElement | null) => void;
    props: {
        'onPointerEnter': () => void;
        'onPointerLeave': () => void;
        'onPointerCancel': () => void;
        'onClick': () => void;
        'onBlur': () => void;
        'aria-describedby'?: string;
    };
}
interface TooltipContextType {
    tooltip: {
        id: string;
        setId: (id: string) => void;
    };
    trigger: TooltipTriggerContextValue;
    disabled: boolean;
    isShown: boolean;
    open: () => void;
    close: () => void;
}
declare const TooltipContext: react.Context<TooltipContextType>;
declare const useTooltip: () => TooltipContextType;
interface TooltipRootProps extends PropsWithChildren {
    isInitiallyShown?: boolean;
    onIsShownChange?: (isShown: boolean) => void;
    appearDelay?: number;
    disabled?: boolean;
}
declare const TooltipRoot: ({ children, isInitiallyShown, onIsShownChange, appearDelay: appearOverwrite, disabled, }: TooltipRootProps) => react_jsx_runtime.JSX.Element;
type TooltipAligment = 'top' | 'bottom' | 'left' | 'right';
interface TooltipDisplayProps extends Omit<AnchoredFloatingContainerProps, 'options' | 'anchor'>, Partial<TooltipConfig> {
    'alignment'?: TooltipAligment;
    'disabled'?: boolean;
    'anchor'?: RefObject<HTMLElement | null>;
    'isShown'?: boolean;
    'options'?: Omit<UseAnchoredPositionOptions, 'verticalAlignment' | 'horizontalAlignment'>;
    'data-name'?: string;
}
declare const TooltipDisplay: react.ForwardRefExoticComponent<TooltipDisplayProps & react.RefAttributes<HTMLDivElement>>;
interface TooltipTriggerBag extends TooltipTriggerContextValue {
    disabled: boolean;
    isShown: boolean;
}
interface TooltipTriggerProps {
    children: (bag: TooltipTriggerBag) => ReactNode;
}
declare const TooltipTrigger: ({ children, }: TooltipTriggerProps) => ReactNode;
interface TooltipProps extends TooltipRootProps, Pick<TooltipDisplayProps, 'alignment' | 'isAnimated'> {
    tooltip: ReactNode;
    containerClassName?: string;
    displayProps?: Omit<TooltipDisplayProps, 'alignment' | 'isAnimated'>;
}
/**
 * A Component for showing a tooltip when hovering over Content
 */
declare const Tooltip: ({ tooltip, children, isInitiallyShown, appearDelay, disabled, containerClassName, alignment, isAnimated, onIsShownChange, displayProps, }: TooltipProps) => react_jsx_runtime.JSX.Element;

/**
 * The different sizes for a icon button
 */
type IconButtonSize = 'xs' | 'sm' | 'md' | 'lg' | null;
type IconButtonColoringStyle = 'outline' | 'solid' | 'text' | 'tonal' | 'tonal-outline' | null;
interface IconButtonBaseProps extends ButtonHTMLAttributes<HTMLButtonElement> {
    /**
     * @default 'medium'
     */
    size?: IconButtonSize;
    /**
     * @default 'solid'
     */
    coloringStyle?: IconButtonColoringStyle;
}
declare const IconButtonBase: react.ForwardRefExoticComponent<IconButtonBaseProps & react.RefAttributes<HTMLButtonElement>>;
interface IconButtonProps extends IconButtonBaseProps {
    useTooltipAsLabel?: boolean;
    tooltip?: ReactNode;
    tooltipProps?: Omit<TooltipDisplayProps, 'children' | 'isShown'>;
}
/**
 * A icon button with a tooltip
 */
declare const IconButton: react.ForwardRefExoticComponent<IconButtonProps & react.RefAttributes<HTMLButtonElement>>;

type DrawerCloseButtonProps = IconButtonProps;
declare function DrawerCloseButton({ tooltip, onClick, ...props }: DrawerCloseButtonProps): react_jsx_runtime.JSX.Element;

type DrawerContainerProps = HTMLAttributes<HTMLDivElement> & {
    alignment: DrawerAligment;
    containerClassName?: string;
    backgroundClassName?: string;
    forceMount?: boolean;
};
declare const DrawerContainer: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
    alignment: DrawerAligment;
    containerClassName?: string;
    backgroundClassName?: string;
    forceMount?: boolean;
} & react.RefAttributes<HTMLDivElement>>;

type DrawerContextType = {
    isOpen: boolean;
    setOpen: Dispatch<SetStateAction<boolean>>;
};
declare const DrawerContext: react.Context<DrawerContextType>;
declare function useDrawerContext(): DrawerContextType;

interface DrawerRootProps extends PropsWithChildren {
    isOpen?: boolean;
    onIsOpenChange?: (isOpen: boolean) => void;
    initialIsOpen?: boolean;
}
declare function DrawerRoot({ children, isOpen: controlledIsOpen, onIsOpenChange, initialIsOpen, }: DrawerRootProps): 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) => react_jsx_runtime.JSX.Element;

type LoadingAnimationProps = {
    loadingText?: string;
    classname?: string;
    animationDuration?: number;
};
declare const LoadingAnimation: ({ loadingText, classname, animationDuration }: LoadingAnimationProps) => react_jsx_runtime.JSX.Element;

type LoadingComponentProps = {
    className?: string;
};
declare const LoadingContainer: ({ className }: LoadingComponentProps) => react_jsx_runtime.JSX.Element;

type BreadCrumbLinkElementProps = AnchorHTMLAttributes<HTMLAnchorElement> & {
    href: string;
};
type BreadCrumbLinkProps = BreadCrumbLinkElementProps & {
    LinkElement?: ElementType<BreadCrumbLinkElementProps>;
};
declare const BreadCrumbLink: ({ LinkElement, className, ...props }: BreadCrumbLinkProps) => react_jsx_runtime.JSX.Element;
type BreadCrumbGroupProps = HTMLAttributes<HTMLUListElement> & {
    divider?: ReactNode | null;
};
/**
 * A component for showing a hierarchical link structure with an independent link on each element
 *
 * e.g. Organizations/Ward/<id>
 */
declare const BreadCrumbGroup: ({ children, divider, ...props }: BreadCrumbGroupProps) => react_jsx_runtime.JSX.Element;
type Crumb = {
    href: string;
    label: ReactNode;
};
type BreadCrumbProps = {
    crumbs: Crumb[];
    LinkElement?: ElementType<BreadCrumbLinkElementProps>;
};
declare const BreadCrumbs: ({ crumbs, LinkElement }: 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 NavigationLinkComponentProps = ComponentPropsWithoutRef<'a'>;
type NavigationItemListProps = Omit<HTMLAttributes<HTMLElement>, 'children'> & {
    items: NavigationItemType[];
    LinkComponent?: ElementType<NavigationLinkComponentProps>;
};
declare const NavigationItemList: ({ items, LinkComponent, ...restProps }: NavigationItemListProps) => react_jsx_runtime.JSX.Element;
type NavigationProps = NavigationItemListProps;
declare const Navigation: ({ ...props }: NavigationProps) => react_jsx_runtime.JSX.Element;

interface PaginationProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
    pageIndex: number;
    pageCount: number;
    onPageIndexChanged?: (pageIndex: number) => void;
}
/**
 * A Component showing the pagination allowing first, before, next and last page navigation
 */
declare const Pagination: ({ pageIndex, pageCount, onPageIndexChanged, ...props }: PaginationProps) => react_jsx_runtime.JSX.Element;

type StepperState = {
    currentStep: number;
    seenSteps: Set<number>;
};
type StepperBarProps = {
    state?: StepperState;
    initialState?: StepperState;
    onStateChange: (state: StepperState) => void;
    numberOfSteps: number;
    disabledSteps?: Set<number>;
    onFinish: () => void;
    finishText?: string;
    showDots?: boolean;
    className?: string;
};
/**
 * A Component for stepping
 */
declare const StepperBar: ({ state: controlledState, initialState, numberOfSteps, disabledSteps, onStateChange, onFinish, finishText, showDots, className, }: StepperBarProps) => react_jsx_runtime.JSX.Element;

type PopUpContextType = {
    isOpen: boolean;
    setIsOpen: Dispatch<SetStateAction<boolean>>;
    popUpId: string;
    triggerId: string;
    triggerRef: RefObject<HTMLElement> | null;
    setTriggerRef: (ref: RefObject<HTMLElement> | null) => void;
};
declare const PopUpContext: react.Context<PopUpContextType>;
declare function usePopUpContext(): PopUpContextType;

interface PopUpOpenerBag<T extends HTMLElement> {
    open: () => void;
    close: () => void;
    isOpen: boolean;
    toggleOpen: () => void;
    props: {
        'id': string;
        'onClick': () => void;
        'aria-haspopup': 'dialog';
        'aria-controls': string;
        'aria-expanded': boolean;
        'ref': RefObject<T>;
    };
}
interface PopUpOpenerProps<T extends HTMLElement> {
    children: (props: PopUpOpenerBag<T>) => ReactNode;
}
declare function PopUpOpener<T extends HTMLElement = HTMLButtonElement>({ children }: PopUpOpenerProps<T>): ReactNode;

interface PopUpRootProps extends PropsWithChildren {
    isOpen?: boolean;
    onIsOpenChange?: (isOpen: boolean) => void;
    initialIsOpen?: boolean;
    popUpId?: string;
    triggerId?: string;
}
declare function PopUpRoot({ children, isOpen: controlledIsOpen, onIsOpenChange, initialIsOpen, popUpId: popUpIdOverwrite, triggerId: triggerIdOverwrite, }: PopUpRootProps): react_jsx_runtime.JSX.Element;

declare const AutoColumnOrderFeature: TableFeature;

declare const ColumnSizingWithTargetFeature: TableFeature;

type FillerCellProps = HTMLAttributes<HTMLDivElement> & {
    'data-name'?: string;
};
declare const FillerCell: ({ ...props }: FillerCellProps) => react_jsx_runtime.JSX.Element;

type ColumnSizingMode = 'fill' | 'natural';
interface TableStateWithoutSizingContextType<T> extends Omit<TableState, 'columnSizing' | 'columnSizingInfo'> {
    table: Table$1<T>;
    data: T[];
    columns: ColumnDef<T>[];
    rowModel: RowModel<T>;
    isUsingFillerRows: boolean;
    columnSizingMode: ColumnSizingMode;
    fillerRowCell: (columnId: string, table: Table$1<T>) => ReactNode;
    onRowClick?: (row: Row<T>, table: Table$1<T>) => void;
    onFillerRowClick?: (index: number, table: Table$1<T>) => void;
}
declare const TableStateWithoutSizingContext: react.Context<TableStateWithoutSizingContextType<any>>;
/**
 * Context for the table state without sizing
 *
 * Use this context to access the table state without sizing
 *
 * This is done to avoid re-rendering the table when the sizing changes rapidly
 */
declare const useTableStateWithoutSizingContext: <T>() => TableStateWithoutSizingContextType<T>;
interface TableStateContextType<T> extends TableState {
    table: Table$1<T>;
    data: T[];
    columns: ColumnDef<T>[];
    rowModel: RowModel<T>;
    isUsingFillerRows: boolean;
    columnSizingMode: ColumnSizingMode;
    fillerRowCell: (columnId: string, table: Table$1<T>) => ReactNode;
    onRowClick?: (row: Row<T>, table: Table$1<T>) => void;
    onFillerRowClick?: (index: number, table: Table$1<T>) => void;
    sizeVars: Record<string, number>;
    targetWidth?: number;
}
declare const TableStateContext: react.Context<TableStateContextType<any>>;
/**
 * Context for the table state
 *
 * Use this context to access the table state and only do cheap operations on it as it can be re-rendered frequently
 */
declare const useTableStateContext: <T>() => TableStateContextType<T>;
type TableContainerContextType<T> = {
    table: Table$1<T>;
    containerRef: RefObject<HTMLDivElement | null>;
};
declare const TableContainerContext: react.Context<TableContainerContextType<any>>;
declare const useTableContainerContext: <T>() => TableContainerContextType<T>;
type TableColumnDefinitionContextType<T> = {
    table: Table$1<T>;
    registerColumn: (column: ColumnDef<T>) => () => void;
};
declare const TableColumnDefinitionContext: react.Context<TableColumnDefinitionContextType<any>>;
declare const useTableColumnDefinitionContext: <T>() => TableColumnDefinitionContextType<T>;

type TableProviderProps<T> = {
    data: T[];
    columns?: ColumnDef<T>[];
    children?: ReactNode;
    placeholderColumnExcludeIds?: string[];
    isUsingFillerRows?: boolean;
    columnSizingMode?: ColumnSizingMode;
    fillerRowCell?: (columnId: string, table: Table$1<T>) => ReactNode;
    initialState?: InitialTableState;
    onRowClick?: (row: Row<T>, table: Table$1<T>) => void;
    onFillerRowClick?: (index: number, table: Table$1<T>) => void;
    state?: Partial<TableState>;
} & Partial<TableOptions<T>>;
declare const TableProvider: <T>({ data, isUsingFillerRows, columnSizingMode, fillerRowCell: fillerRowCellOverwrite, initialState, onRowClick, onFillerRowClick, defaultColumn: defaultColumnOverwrite, state, columns: columnsProp, placeholderColumnExcludeIds, children, ...tableOptions }: TableProviderProps<T>) => react_jsx_runtime.JSX.Element;

declare module '@tanstack/react-table' {
    interface ColumnMeta<TData extends RowData, TValue> {
        className?: string;
        filterData?: {
            tags?: {
                tag: string;
                label: string;
                display?: ReactNode;
            }[];
        };
        columnLabel?: string;
    }
    interface TableMeta<TData> {
        headerRowClassName?: string;
        bodyRowClassName?: ((value: TData) => string) | string;
    }
    interface FilterFns {
        text: FilterFn<unknown>;
        number: FilterFn<unknown>;
        date: FilterFn<unknown>;
        dateTime: FilterFn<unknown>;
        boolean: FilterFn<unknown>;
        multiTags: FilterFn<unknown>;
        singleTag: FilterFn<unknown>;
        unknownType: FilterFn<unknown>;
    }
    interface TableOptions<TData extends RowData> {
        columnSizingTarget?: number;
    }
    interface TableOptionsResolved<TData extends RowData> {
        columnSizingTarget?: number;
    }
}

type TableHeaderProps = {
    isSticky?: boolean;
};
declare const TableHeader: ({ isSticky }: TableHeaderProps) => react_jsx_runtime.JSX.Element;

/**
 * Determines which element a virtualized list scrolls inside of.
 *
 * - `'container'`: the list scrolls inside its own capped box (the list owns a
 *    `overflow-y-auto` element). Use when the list should keep a fixed height.
 * - `'window'`: the list scrolls together with the document/`window`.
 * - `'page'`: the list scrolls together with the nearest scrollable ancestor
 *    (e.g. the `AppPage` content area). Use when the surrounding page should
 *    expand and scroll as one, instead of the list scrolling inside a capped box.
 */
type VirtualizationScroll = 'window' | 'container' | 'page';
/**
 * Walks up the DOM from `element` and returns the nearest ancestor that is an
 * actual vertical scroll container. Backs the `'page'` virtualization mode so a
 * virtualized list can scroll together with the surrounding page instead of
 * inside its own capped box.
 */
declare function findScrollableAncestor(element: HTMLElement | null): HTMLElement | null;
/** Marks the {@link AppPage} content area — the scroll container for `'page'` mode. */
declare const APP_PAGE_CONTENT_SELECTOR = "[data-name=\"app-page-content\"]";
/**
 * Resolves the scroll container for the `'page'` virtualization mode. Prefers the
 * {@link AppPage} content area, which is a real scroll container regardless of how
 * much content is currently loaded — resolving by overflow state alone would
 * deadlock a virtualized list whose data arrives after mount (empty content →
 * no overflow → no scroll element → no rows → still no overflow). Falls back to
 * the nearest scrollable ancestor for non-AppPage contexts.
 */
declare function findPageScrollContainer(element: HTMLElement | null): HTMLElement | null;
type ScrollMetrics = {
    scrollTop: number;
    scrollHeight: number;
    clientHeight: number;
};
/** Reads scroll metrics uniformly from either an element or the `window`. */
declare function getScrollMetrics(target: HTMLElement | Window | null): ScrollMetrics;
declare function isNearBottom(metrics: ScrollMetrics, thresholdPx: number): boolean;

type TableVirtualizationOptions = {
    estimateRowHeight?: number;
    overscan?: number;
    scroll?: VirtualizationScroll;
    /** Called for infinite scroll while nearing the bottom of the scroll region. */
    onReachBottom?: () => void;
    reachBottomThresholdPx?: number;
};
type VirtualizedTableBodyProps = TableVirtualizationOptions;
declare const VirtualizedTableBody: ({ estimateRowHeight, overscan, scroll, onReachBottom, reachBottomThresholdPx, }: VirtualizedTableBodyProps) => react_jsx_runtime.JSX.Element;

interface TableDisplayProps extends TableHTMLAttributes<HTMLTableElement> {
    'containerProps'?: Omit<React.HTMLAttributes<HTMLDivElement>, 'children'> & {
        'data-name'?: string;
    };
    'tableHeaderProps'?: Omit<TableHeaderProps, 'children' | 'table'>;
    'virtualized'?: boolean | TableVirtualizationOptions;
    'data-name'?: string;
}
/**
 * A display component for a table that requires a TableProvider for the table context
 */
declare const TableDisplay: <T>({ children, containerProps, tableHeaderProps, virtualized, ...props }: TableDisplayProps) => react_jsx_runtime.JSX.Element;

type TablePaginationMenuProps = Omit<PaginationProps, 'pageIndex' | 'pageCount'>;
declare const TablePaginationMenu: ({ ...props }: TablePaginationMenuProps) => react_jsx_runtime.JSX.Element;
interface TablePageSizeSelectProps extends Omit<SelectProps, 'children'> {
    pageSizeOptions?: number[];
}
declare const TablePageSizeSelect: ({ pageSizeOptions, ...props }: TablePageSizeSelectProps) => react_jsx_runtime.JSX.Element;
interface TablePaginationProps extends HTMLAttributes<HTMLDivElement> {
    allowChangingPageSize?: boolean;
    pageSizeOptions?: number[];
}
declare const TablePagination: ({ allowChangingPageSize, pageSizeOptions, ...props }: TablePaginationProps) => react_jsx_runtime.JSX.Element;

interface TableWithSelectionProviderProps<T> extends TableProviderProps<T> {
    rowSelection: RowSelectionState;
    disableClickRowClickSelection?: boolean;
    selectionRowId?: string;
}
declare const TableWithSelectionProvider: <T>({ children, state, fillerRowCell, rowSelection, disableClickRowClickSelection, selectionRowId, onRowClick, ...props }: TableWithSelectionProviderProps<T>) => react_jsx_runtime.JSX.Element;

interface TableProps<T> extends HTMLAttributes<HTMLDivElement> {
    table: TableProviderProps<T>;
    paginationOptions?: TablePaginationProps & {
        showPagination?: boolean;
    };
    displayProps?: Omit<TableDisplayProps, 'children'>;
    header?: React.ReactNode;
    footer?: React.ReactNode;
}
declare const Table: <T>({ children, table, paginationOptions, displayProps, header, footer, ...props }: TableProps<T>) => react_jsx_runtime.JSX.Element;
interface TableWithSelectionProps<T> extends HTMLAttributes<HTMLDivElement> {
    table: TableWithSelectionProviderProps<T>;
    paginationOptions?: TablePaginationProps & {
        showPagination?: boolean;
    };
    displayProps?: Omit<TableDisplayProps, 'children'>;
    header?: React.ReactNode;
    footer?: React.ReactNode;
}
declare const TableWithSelection: <T>({ children, table, paginationOptions, displayProps, header, footer, ...props }: TableWithSelectionProps<T>) => react_jsx_runtime.JSX.Element;

declare const TableBody: react__default.NamedExoticComponent<object>;

type TableCellProps = PropsWithChildren<{
    className?: string;
}>;
declare const TableCell: ({ children, className, }: TableCellProps) => react_jsx_runtime.JSX.Element;

declare const dataTypes: readonly ["text", "number", "date", "dateTime", "boolean", "singleTag", "multiTags", "unknownType"];
type DataType = (typeof dataTypes)[number];
interface DataValue {
    textValue?: string;
    numberValue?: number;
    booleanValue?: boolean;
    dateValue?: Date;
    singleSelectValue?: string;
    multiSelectValue?: string[];
}
declare function toIcon(type: DataType): ReactNode;
declare const DataTypeUtils: {
    types: readonly ["text", "number", "date", "dateTime", "boolean", "singleTag", "multiTags", "unknownType"];
    getDefaultValue: (type: DataType, selectOptions?: string[]) => DataValue;
    toIcon: typeof toIcon;
};

type TableColumnProps<T> = ColumnDef<T> & {
    filterType?: DataType;
};
declare const TableColumn: <T>(props: TableColumnProps<T>) => react_jsx_runtime.JSX.Element;

type TableColumnSwitcherPopUpProps = PopUpProps;
declare const TableColumnSwitcherPopUp: ({ ...props }: TableColumnSwitcherPopUpProps) => react_jsx_runtime.JSX.Element;
interface TableColumnSwitcherProps extends TableColumnSwitcherPopUpProps {
    buttonProps?: ButtonProps;
}
declare const TableColumnSwitcher: ({ buttonProps, ...props }: TableColumnSwitcherProps) => react_jsx_runtime.JSX.Element;

declare const TableFilter: {
    text: FilterFn<unknown>;
    number: FilterFn<unknown>;
    date: FilterFn<unknown>;
    dateTime: FilterFn<unknown>;
    boolean: FilterFn<unknown>;
    multiTags: FilterFn<unknown>;
    singleTag: FilterFn<unknown>;
    unknownType: FilterFn<unknown>;
};

type TableFilterButtonProps = {
    filterType: DataType;
    header: Header<unknown, unknown>;
};
declare const TableFilterButton: ({ filterType, header, }: TableFilterButtonProps) => react_jsx_runtime.JSX.Element;

type SortingIndexDisplay = {
    index: number;
    sortingsCount: number;
};
type TableSortButtonProps = IconButtonProps & {
    sortDirection: SortDirection | false;
    sortingIndexDisplay?: SortingIndexDisplay;
    invert?: boolean;
};
/**
 * An Extension of the normal button that displays the sorting state right of the content
 */
declare const TableSortButton: ({ sortDirection, invert, color, size, className, sortingIndexDisplay, ...props }: TableSortButtonProps) => react_jsx_runtime.JSX.Element;

type ColumnSizeCalculateTargetBehavoir = 'equalOrHigher';
type ColumnSizeCalculateTarget = {
    width: number;
    behaviour: ColumnSizeCalculateTargetBehavoir;
};
type ColumnSizeCalculatoProps = {
    previousSizing: Record<string, number>;
    newSizing: Record<string, number>;
    columnIds: string[];
    target?: ColumnSizeCalculateTarget;
    minWidthsPerColumn: Record<string, number>;
    maxWidthsPerColumn?: Record<string, number>;
};
declare const toSizeVars: (sizing: ColumnSizingState) => {};
declare const ColumnSizeUtil: {
    calculate: ({ previousSizing, newSizing, columnIds, target, minWidthsPerColumn, maxWidthsPerColumn }: ColumnSizeCalculatoProps) => {
        [x: string]: number;
    };
    toSizeVars: (sizing: ColumnSizingState) => {};
};

declare const NO_COLUMN_ID = "no-column";
declare const createNoColumnPlaceholderColumn: <T>(translation: (key: string) => string) => ColumnDef<T>;
declare const hasNonExcludedColumns: <T>(columns: ColumnDef<T>[], excludeIds: string[]) => boolean;

type UseNaturalColumnWidthLockOptions<T> = {
    table: Table$1<T>;
    tableRef: RefObject<HTMLTableElement | null>;
    enabled: boolean;
};
declare function useNaturalColumnWidthLock<T>({ table, tableRef, enabled, }: UseNaturalColumnWidthLockOptions<T>): boolean;

type VirtualizedCardGridProps<T> = {
    items: readonly T[];
    getItemKey: (item: T) => string;
    renderItem: (item: T) => ReactNode;
    /** Minimum width a card may shrink to before the column count drops. */
    minCardWidthPx: number;
    gapPx?: number;
    estimateRowHeightPx?: number;
    overscanRows?: number;
    /** Below this item count the grid renders every card without virtualization. */
    virtualizeThreshold?: number;
    /** Where the grid scrolls. Defaults to `'container'` (its own capped box). */
    scroll?: VirtualizationScroll;
    containerClassName?: string;
    /** Called for infinite scroll while nearing the bottom of the scroll region. */
    onReachBottom?: () => void;
    reachBottomThresholdPx?: number;
};
/**
 * A responsive, virtualized grid of cards backed by TanStack Virtual. Shares its
 * scroll handling ({@link VirtualizationScroll} modes + infinite scroll) with
 * the virtualized table via {@link useVirtualizedRows}, so a card grid and a
 * table can behave identically inside the same scroll region.
 */
declare function VirtualizedCardGrid<T>({ items, getItemKey, renderItem, minCardWidthPx, gapPx, estimateRowHeightPx, overscanRows, virtualizeThreshold, scroll, containerClassName, onReachBottom, reachBottomThresholdPx, }: VirtualizedCardGridProps<T>): react_jsx_runtime.JSX.Element;

/** Number of columns that fit into `containerWidth` given a minimum card width. */
declare function columnsForWidth(containerWidth: number, minCardWidthPx: number, gapPx: number): number;
/**
 * Number of rows to render outside the visible window so that a fast (e.g. mobile
 * momentum) scroll does not outrun React's render and reveal blank space. Derives
 * the row count from a target pixel buffer and the (estimated) row height, never
 * dropping below `minRows`.
 */
declare function overscanRowsForBuffer(bufferPx: number, rowHeightPx: number, minRows?: number): number;
/** Splits `items` into rows of at most `columns` entries each. */
declare function chunkIntoRows<T>(items: readonly T[], columns: number): T[][];

type UseVirtualizedRowsOptions = {
    scroll: VirtualizationScroll;
    count: number;
    estimateRowHeight: number;
    overscan: number;
    enabled?: boolean;
    getItemKey?: (index: number) => Key;
    /**
     * The element whose top marks where the virtualized content starts (e.g. the
     * `tbody` for a table, or the grid wrapper for a card grid). Used to measure
     * the scroll offset for the `'window'` and `'page'` modes.
     */
    contentRef: RefObject<HTMLElement | null>;
    /** The scroll container element for the `'container'` mode. */
    containerRef?: RefObject<HTMLElement | null>;
    /** Called while the rendered range is within `reachBottomThresholdPx` of the end. */
    onReachBottom?: () => void;
    reachBottomThresholdPx?: number;
};
type UseVirtualizedRowsResult = {
    virtualizer: Virtualizer<Element, Element>;
    /** Subtract from `virtualItem.start` to get a position relative to `contentRef`. */
    offset: number;
    /** The resolved scrollable ancestor for the `'page'` mode (else `null`). */
    pageScrollElement: HTMLElement | null;
    isMounted: boolean;
};
/**
 * Shared virtualization plumbing for the table and card grid. Selects the right
 * TanStack virtualizer for the requested {@link VirtualizationScroll} mode,
 * measures the content offset for outer-scroll modes, resolves the page scroll
 * container, and wires up "reached the bottom" callbacks for infinite scroll.
 */
declare function useVirtualizedRows({ scroll, count, estimateRowHeight, overscan, enabled, getItemKey, contentRef, containerRef, onReachBottom, reachBottomThresholdPx, }: UseVirtualizedRowsOptions): UseVirtualizedRowsResult;

type CheckBoxSize = 'sm' | 'md' | 'lg' | null;
type CheckboxProps = HTMLAttributes<HTMLDivElement> & Partial<FormFieldInteractionStates> & Partial<FormFieldDataHandling<boolean>> & {
    initialValue?: boolean;
    indeterminate?: boolean;
    size?: CheckBoxSize;
    alwaysShowCheckIcon?: boolean;
    isRounded?: boolean;
    interactive?: boolean;
};
/**
 * A Tristate checkbox
 *
 * The state is managed by the parent
 */
declare const Checkbox: ({ value: controlledValue, initialValue, indeterminate, required, invalid, disabled, readOnly, onValueChange, onEditComplete, size, alwaysShowCheckIcon, isRounded, ...props }: CheckboxProps) => react_jsx_runtime.JSX.Element;

type ComboboxInputProps = Omit<ComponentProps<typeof Input>, 'value'>;
declare const ComboboxInput: react.ForwardRefExoticComponent<Omit<ComboboxInputProps, "ref"> & react.RefAttributes<HTMLInputElement>>;

type ComboboxListProps = HTMLAttributes<HTMLUListElement>;
declare const ComboboxList: react.ForwardRefExoticComponent<ComboboxListProps & react.RefAttributes<HTMLUListElement>>;

interface ComboboxProps<T = string> {
    children: ReactNode;
    onItemClick?: (value: T) => void;
    id?: string;
    searchQuery?: string;
    onSearchQueryChange?: (value: string) => void;
    initialSearchQuery?: string;
    inputProps?: ComboboxInputProps;
    listProps?: ComboboxListProps;
}
declare const Combobox: <T = string>(props: ComboboxProps<T> & React.RefAttributes<HTMLDivElement>) => JSX.Element;

interface ComboboxOptionType<T = string> {
    id: string;
    value: T;
    label?: string;
    display?: ReactNode;
    disabled?: boolean;
    ref: RefObject<HTMLElement>;
}
interface ComboboxContextIds {
    trigger: string;
    listbox: string;
}
interface ComboboxContextInternalState {
    highlightedId: string | null;
}
interface ComboboxContextComputedState<T> {
    options: ReadonlyArray<ComboboxOptionType<T>>;
    visibleOptionIds: ReadonlyArray<string>;
    idToOptionMap: Record<string, ComboboxOptionType<T>>;
}
interface ComboboxContextActions<T> {
    registerOption(option: ComboboxOptionType<T>): () => void;
    selectOption(id: string): void;
    highlightFirst(): void;
    highlightLast(): void;
    highlightNext(): void;
    highlightPrevious(): void;
    highlightItem(id: string): void;
}
interface ComboboxContextLayout {
    listRef: RefObject<HTMLUListElement | null>;
    registerList(ref: RefObject<HTMLUListElement | null>): () => void;
}
interface ComboboxContextSearch {
    searchQuery: string;
    setSearchQuery(query: string): void;
}
interface ComboboxContextConfig {
    ids: ComboboxContextIds;
    setIds: Dispatch<SetStateAction<ComboboxContextIds>>;
}
interface ComboboxContextType<T> extends ComboboxContextInternalState, ComboboxContextComputedState<T>, ComboboxContextActions<T> {
    config: ComboboxContextConfig;
    layout: ComboboxContextLayout;
    search: ComboboxContextSearch;
}
declare const ComboboxContext: react.Context<ComboboxContextType<unknown>>;
declare function useComboboxContext<T = string>(): ComboboxContextType<T>;

interface ComboboxOptionProps<T = string> extends HTMLAttributes<HTMLLIElement> {
    value: T;
    label: string;
    disabled?: boolean;
}
declare const ComboboxOption: react.ForwardRefExoticComponent<ComboboxOptionProps<unknown> & react.RefAttributes<HTMLLIElement>>;

interface UseComboboxOption {
    id: string;
    label?: string;
    disabled?: boolean;
}
interface UseComboboxOptions {
    options: ReadonlyArray<UseComboboxOption>;
    searchQuery?: string;
    onSearchQueryChange?: (query: string) => void;
    initialSearchQuery?: string;
}
interface UseComboboxState {
    searchQuery: string;
    highlightedId: string | null;
}
interface UseComboboxComputedState {
    visibleOptionIds: ReadonlyArray<string>;
}
interface UseComboboxActions {
    setSearchQuery: (query: string) => void;
    highlightFirst: () => void;
    highlightLast: () => void;
    highlightNext: () => void;
    highlightPrevious: () => void;
    highlightItem: (id: string) => void;
}
interface UseComboboxReturn extends UseComboboxState, UseComboboxComputedState, UseComboboxActions {
}
declare function useCombobox({ options, searchQuery: controlledSearchQuery, onSearchQueryChange, initialSearchQuery, }: UseComboboxOptions): UseComboboxReturn;

interface ComboboxRootProps<T = string> extends Omit<UseComboboxOptions, 'options'> {
    children: ReactNode;
    onItemClick?: (value: T) => void;
}
declare function ComboboxRoot<T = string>({ children, onItemClick, ...hookProps }: ComboboxRootProps<T>): react_jsx_runtime.JSX.Element;

interface CopyToClipboardWrapperProps extends Omit<TooltipProps, 'tooltip'> {
    textToCopy: string;
}
/**
 * A Component for showing a tooltip when hovering over Content
 */
declare const CopyToClipboardWrapper: ({ children, textToCopy, isInitiallyShown, appearDelay, disabled, containerClassName, alignment, isAnimated, ...props }: CopyToClipboardWrapperProps) => react_jsx_runtime.JSX.Element;

type LabelledCheckboxCheckPosition = 'left' | 'right';
type LabelledCheckboxProps = Omit<HTMLAttributes<HTMLDivElement>, 'children'> & Partial<FormFieldInteractionStates> & Partial<FormFieldDataHandling<boolean>> & Pick<CheckboxProps, 'indeterminate' | 'size' | 'alwaysShowCheckIcon' | 'isRounded'> & {
    initialValue?: boolean;
    label: ReactNode;
    checkPosition?: LabelledCheckboxCheckPosition;
    checkboxClassName?: string;
    labelClassName?: string;
};
/**
 * A checkbox with a label that toggles the checkbox when the container is clicked
 */
declare const LabelledCheckbox: react.ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDivElement>, "children"> & Partial<FormFieldInteractionStates> & Partial<FormFieldDataHandling<boolean>> & Pick<CheckboxProps, "size" | "indeterminate" | "alwaysShowCheckIcon" | "isRounded"> & {
    initialValue?: boolean;
    label: ReactNode;
    checkPosition?: LabelledCheckboxCheckPosition;
    checkboxClassName?: string;
    labelClassName?: string;
} & react.RefAttributes<HTMLDivElement>>;

type MenuItemProps = {
    onClick?: () => void;
    isDisabled?: boolean;
    className?: string;
};
declare const MenuItem: ({ children, onClick, isDisabled, className }: PropsWithChildren<MenuItemProps>) => react_jsx_runtime.JSX.Element;
type MenuBag = {
    isOpen: boolean;
    disabled: boolean;
    toggleOpen: () => void;
    close: () => void;
};
interface MenuProps extends Omit<PopUpProps, 'children' | 'anchor'> {
    children: (bag: MenuBag) => ReactNode | ReactNode;
    trigger: (bag: MenuBag, ref: (el: HTMLElement | null) => void) => ReactNode;
    disabled?: boolean;
}
/**
 * A Menu Component to allow the user to see different functions
 */
declare const Menu: ({ trigger, children, disabled, ...props }: MenuProps) => react_jsx_runtime.JSX.Element;

interface UseMultiSelectOption {
    id: string;
    label?: string;
    disabled?: boolean;
}
interface UseMultiSelectOptions {
    options: ReadonlyArray<UseMultiSelectOption>;
    value?: ReadonlyArray<string>;
    onValueChange?: (value: string[]) => void;
    onEditComplete?: (value: string[]) => void;
    initialValue?: string[];
    initialIsOpen?: boolean;
    onClose?: () => void;
    typeAheadResetMs?: number;
}
type UseMultiSelectFirstHighlightBehavior = 'first' | 'last';
interface UseMultiSelectState {
    value: string[];
    highlightedId: string | null;
    isOpen: boolean;
    searchQuery: string;
    options: ReadonlyArray<UseMultiSelectOption>;
}
interface UseMultiSelectComputedState {
    visibleOptionIds: ReadonlyArray<string>;
}
interface UseMultiSelectActions {
    setIsOpen: (isOpen: boolean, behavior?: UseMultiSelectFirstHighlightBehavior) => void;
    toggleOpen: (behavior?: UseMultiSelectFirstHighlightBehavior) => void;
    setSearchQuery: (query: string) => void;
    highlightFirst: () => void;
    highlightLast: () => void;
    highlightNext: () => void;
    highlightPrevious: () => void;
    highlightItem: (id: string) => void;
    toggleSelection: (id: string, isSelected?: boolean) => void;
    setSelection: (ids: string[]) => void;
    isSelected: (id: string) => boolean;
    handleTypeaheadKey: (key: string) => void;
}
interface UseMultiSelectReturn extends UseMultiSelectState, UseMultiSelectComputedState, UseMultiSelectActions {
}
declare function useMultiSelect({ options, value: controlledValue, onValueChange, onEditComplete, initialValue, onClose, initialIsOpen, typeAheadResetMs, }: UseMultiSelectOptions): UseMultiSelectReturn;

interface MultiSelectOptionType<T = string> {
    id: string;
    value: T;
    label?: string;
    display?: ReactNode;
    disabled?: boolean;
    ref: RefObject<HTMLElement | null>;
}
interface MultiSelectContextIds {
    trigger: string;
    content: string;
    listbox: string;
    searchInput: string;
}
interface MultiSelectContextState<T> extends FormFieldInteractionStates {
    value: T[];
    options: ReadonlyArray<MultiSelectOptionType<T>>;
    selectedIds: string[];
    highlightedId: string | null;
    isOpen: boolean;
}
interface MultiSelectContextComputedState<T> {
    visibleOptionIds: ReadonlyArray<string>;
    idToOptionMap: Record<string, MultiSelectOptionType<T>>;
}
interface MultiSelectContextActions<T> {
    registerOption(option: MultiSelectOptionType<T>): () => void;
    toggleSelection(id: string, isSelected?: boolean): void;
    highlightFirst(): void;
    highlightLast(): void;
    highlightNext(): void;
    highlightPrevious(): void;
    highlightItem(id: string): void;
    handleTypeaheadKey(key: string): void;
    setIsOpen(open: boolean, behavior?: UseMultiSelectFirstHighlightBehavior): void;
    toggleIsOpen(behavior?: UseMultiSelectFirstHighlightBehavior): void;
}
interface MultiSelectContextLayout {
    triggerRef: RefObject<HTMLElement | null>;
    registerTrigger(element: RefObject<HTMLElement | null>): () => void;
}
interface MultiSelectContextSearch {
    hasSearch: boolean;
    searchQuery?: string;
    setSearchQuery(query: string): void;
}
type MultiSelectIconAppearance = 'left' | 'right' | 'none';
interface MultiSelectContextConfig {
    iconAppearance: MultiSelectIconAppearance;
    ids: MultiSelectContextIds;
    setIds: Dispatch<SetStateAction<MultiSelectContextIds>>;
}
interface MultiSelectContextType<T> extends MultiSelectContextActions<T>, MultiSelectContextState<T>, MultiSelectContextComputedState<T> {
    config: MultiSelectContextConfig;
    layout: MultiSelectContextLayout;
    search: MultiSelectContextSearch;
}
declare const MultiSelectContext: react.Context<MultiSelectContextType<unknown>>;
declare function useMultiSelectContext<T>(): MultiSelectContextType<T>;

interface MultiSelectIds {
    trigger: string;
    content: string;
    listbox: string;
    searchInput: string;
}
interface MultiSelectRootProps<T> extends Partial<FormFieldDataHandling<T[]>>, Partial<FormFieldInteractionStates> {
    initialValue?: T[];
    compareFunction?: (a: T, b: T) => boolean;
    initialIsOpen?: boolean;
    onClose?: () => void;
    showSearch?: boolean;
    iconAppearance?: MultiSelectIconAppearance;
    children: ReactNode;
}
declare function MultiSelectRoot<T>({ children, value, onValueChange, onEditComplete, initialValue, compareFunction, initialIsOpen, onClose, showSearch, iconAppearance, invalid, disabled, readOnly, required, }: MultiSelectRootProps<T>): react_jsx_runtime.JSX.Element;

interface MultiSelectButtonProps<T = string> extends ComponentPropsWithoutRef<'div'> {
    'placeholder'?: ReactNode;
    'disabled'?: boolean;
    'selectedDisplay'?: (values: T[]) => ReactNode;
    'hideExpansionIcon'?: boolean;
    'data-name'?: string;
}
declare const MultiSelectButton: react.ForwardRefExoticComponent<MultiSelectButtonProps<unknown> & react.RefAttributes<HTMLDivElement>>;

interface MultiSelectContentProps extends PopUpProps {
    showSearch?: boolean;
    searchInputProps?: Omit<ComponentProps<typeof Input>, 'value' | 'onValueChange'>;
}
declare const MultiSelectContent: react.ForwardRefExoticComponent<MultiSelectContentProps & react.RefAttributes<HTMLUListElement>>;

interface MultiSelectProps<T = string> extends MultiSelectRootProps<T> {
    contentPanelProps?: MultiSelectContentProps;
    buttonProps?: MultiSelectButtonProps<T>;
}
declare const MultiSelect: <T = string>(props: MultiSelectProps<T> & {
    ref?: React.Ref<HTMLDivElement>;
}) => React.ReactElement;

type MultiSelectChipDisplayButtonProps = HTMLAttributes<HTMLDivElement> & {
    'disabled'?: boolean;
    'placeholder'?: ReactNode;
    'data-name'?: string;
};
declare const MultiSelectChipDisplayButton: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
    disabled?: boolean;
    placeholder?: ReactNode;
    'data-name'?: string;
} & react.RefAttributes<HTMLDivElement>>;
type MultiSelectChipDisplayProps<T = string> = MultiSelectRootProps<T> & {
    contentPanelProps?: MultiSelectContentProps;
    chipDisplayProps?: MultiSelectChipDisplayButtonProps;
};
declare const MultiSelectChipDisplay: react.ForwardRefExoticComponent<MultiSelectRootProps<unknown> & {
    contentPanelProps?: MultiSelectContentProps;
    chipDisplayProps?: MultiSelectChipDisplayButtonProps;
} & react.RefAttributes<HTMLDivElement>>;

type MultiSelectOptionDisplayLocation = 'trigger' | 'list';
declare const MultiSelectOptionDisplayContext: react.Context<MultiSelectOptionDisplayLocation>;
declare function useMultiSelectOptionDisplayLocation(): MultiSelectOptionDisplayLocation;
interface MultiSelectOptionProps<T = string> extends HTMLAttributes<HTMLLIElement> {
    value: T;
    label: string;
    disabled?: boolean;
    iconAppearance?: MultiSelectIconAppearance;
}
declare const MultiSelectOption: react.ForwardRefExoticComponent<MultiSelectOptionProps<unknown> & react.RefAttributes<HTMLLIElement>>;

type ScrollPickerProps<T> = {
    options: T[];
    mapping: (value: T) => string;
    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 SelectOptionDisplayLocation = 'trigger' | 'list';
declare const SelectOptionDisplayContext: react.Context<SelectOptionDisplayLocation>;
declare function useSelectOptionDisplayLocation(): SelectOptionDisplayLocation;
interface SelectOptionProps<T = string> extends HTMLAttributes<HTMLLIElement> {
    value: T;
    label: string;
    disabled?: boolean;
    iconAppearance?: SelectIconAppearance;
}
declare const SelectOption: react.ForwardRefExoticComponent<SelectOptionProps<unknown> & react.RefAttributes<HTMLLIElement>>;

type SwitchProps = HTMLAttributes<HTMLDivElement> & Partial<FormFieldInteractionStates> & Partial<FormFieldDataHandling<boolean>> & {
    initialValue?: boolean;
};
/**
 * A binary on/off switch
 *
 * The state is managed by the parent.
 */
declare const Switch: ({ value: controlledValue, initialValue, required, invalid, disabled, readOnly, onValueChange, onEditComplete, ...props }: SwitchProps) => react_jsx_runtime.JSX.Element;

type TextareaProps = Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, 'value'> & Partial<FormFieldDataHandling<string>> & Partial<FormFieldInteractionStates> & {
    initialValue?: string;
    saveDelayOptions?: UseDelayOptions;
};
/**
 * A Textarea component for inputting longer texts
 *
 * The State is managed by the parent
 */
declare const Textarea: react.ForwardRefExoticComponent<Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, "value"> & Partial<FormFieldDataHandling<string>> & Partial<FormFieldInteractionStates> & {
    initialValue?: string;
    saveDelayOptions?: UseDelayOptions;
} & react.RefAttributes<HTMLTextAreaElement>>;
type TextareaWithHeadlineProps = Omit<TextareaProps, 'defaultStyle'> & {
    headline: ReactNode;
    headlineProps: Omit<LabelHTMLAttributes<HTMLLabelElement>, 'children'>;
    containerClassName?: string;
};
declare const TextareaWithHeadline: ({ id, headline, headlineProps, disabled, className, containerClassName, ...props }: TextareaWithHeadlineProps) => react_jsx_runtime.JSX.Element;

declare const filterOperators: readonly ["equals", "notEquals", "contains", "notContains", "startsWith", "endsWith", "greaterThan", "greaterThanOrEqual", "lessThan", "lessThanOrEqual", "between", "notBetween", "isTrue", "isFalse", "isUndefined", "isNotUndefined"];
type FilterOperator = (typeof filterOperators)[number];
declare const filterOperatorsByCategory: Record<DataType, FilterOperator[]>;
type FilterOperatorUnknownType = (typeof filterOperatorsByCategory.unknownType)[number];
type FilterOperatorText = (typeof filterOperatorsByCategory.text)[number];
type FilterOperatorNumber = (typeof filterOperatorsByCategory.number)[number];
type FilterOperatorDate = (typeof filterOperatorsByCategory.date)[number];
type FilterOperatorDatetime = (typeof filterOperatorsByCategory.dateTime)[number];
type FilterOperatorBoolean = (typeof filterOperatorsByCategory.boolean)[number];
type FilterOperatorTags = (typeof filterOperatorsByCategory.multiTags)[number];
type FilterOperatorTagsSingle = (typeof filterOperatorsByCategory.singleTag)[number];
declare function isFilterOperatorText(value: unknown): value is FilterOperatorText;
declare function isFilterOperatorNumber(value: unknown): value is FilterOperatorNumber;
declare function isFilterOperatorDate(value: unknown): value is FilterOperatorDate;
declare function isFilterOperatorDatetime(value: unknown): value is FilterOperatorDatetime;
declare function isFilterOperatorBoolean(value: unknown): value is FilterOperatorBoolean;
declare function isFilterOperatorTags(value: unknown): value is FilterOperatorTags;
declare function isFilterOperatorTagsSingle(value: unknown): value is FilterOperatorTagsSingle;
declare function isFilterOperatorUnknownType(value: unknown): value is FilterOperatorUnknownType;
declare function isFilterOperator(value: unknown): value is FilterOperator;
type OperatorInfoResult = {
    icon: ReactNode;
    translationKey: string;
    replacementTranslationKey: string;
};
declare function getDefaultOperator(dataType: DataType): FilterOperator;
declare const FilterOperatorUtils: {
    operators: readonly ["equals", "notEquals", "contains", "notContains", "startsWith", "endsWith", "greaterThan", "greaterThanOrEqual", "lessThan", "lessThanOrEqual", "between", "notBetween", "isTrue", "isFalse", "isUndefined", "isNotUndefined"];
    operatorsByCategory: Record<"number" | "boolean" | "text" | "date" | "dateTime" | "multiTags" | "singleTag" | "unknownType", ("endsWith" | "startsWith" | "between" | "contains" | "equals" | "greaterThan" | "greaterThanOrEqual" | "isFalse" | "isNotUndefined" | "isTrue" | "isUndefined" | "lessThan" | "lessThanOrEqual" | "notBetween" | "notContains" | "notEquals")[]>;
    getInfo: (operator: FilterOperator) => OperatorInfoResult;
    getDefaultOperator: typeof getDefaultOperator;
    typeCheck: {
        all: typeof isFilterOperator;
        text: typeof isFilterOperatorText;
        number: typeof isFilterOperatorNumber;
        date: typeof isFilterOperatorDate;
        datetime: typeof isFilterOperatorDatetime;
        boolean: typeof isFilterOperatorBoolean;
        tags: typeof isFilterOperatorTags;
        tagsSingle: typeof isFilterOperatorTagsSingle;
        unknownType: typeof isFilterOperatorUnknownType;
    };
};

type FilterParameter = {
    stringValue?: string;
    numberValue?: number;
    numberMin?: number;
    numberMax?: number;
    booleanValue?: boolean;
    dateValue?: Date;
    dateMin?: Date;
    dateMax?: Date;
    uuidValue?: unknown;
    uuidValues?: unknown[];
};
type FilterValue = {
    dataType: DataType;
    operator: FilterOperator;
    parameter: FilterParameter;
};
declare function isFilterValueValid(value: FilterValue): boolean;
declare const FilterValueUtils: {
    allowedOperatorsByDataType: Record<"number" | "boolean" | "text" | "date" | "dateTime" | "multiTags" | "singleTag" | "unknownType", ("endsWith" | "startsWith" | "between" | "contains" | "equals" | "greaterThan" | "greaterThanOrEqual" | "isFalse" | "isNotUndefined" | "isTrue" | "isUndefined" | "lessThan" | "lessThanOrEqual" | "notBetween" | "notContains" | "notEquals")[]>;
    isValid: typeof isFilterValueValid;
};
declare const FilterFunctions: Record<DataType, (value: unknown, operator: FilterOperator, parameter: FilterParameter) => boolean>;
type FilterValueTranslationOptions = {
    tags?: ReadonlyArray<{
        tag: string;
        label: string;
    }>;
};
declare function useFilterValueTranslation(): (value: FilterValue, options?: FilterValueTranslationOptions) => string;

interface IdentifierFilterValue extends ColumnFilter {
    value: FilterValue;
}
interface FilterListPopUpBuilderProps {
    value: FilterValue;
    onValueChange: (value: FilterValue) => void;
    onRemove: () => void;
    operatorOverrides?: FilterOperator[];
    dataType: DataType;
    tags: ReadonlyArray<{
        tag: string;
        label: string;
        display?: ReactNode;
    }>;
    name: string;
    isOpen: boolean;
    onClose: () => void;
}
interface FilterListItem {
    id: string;
    label: string;
    dataType: DataType;
    tags: ReadonlyArray<{
        tag: string;
        label: string;
        display?: ReactNode;
    }>;
    operatorOverrides?: FilterOperator[];
    popUpBuilder?: (props: FilterListPopUpBuilderProps) => ReactNode;
    activeLabelBuilder?: (value: FilterValue) => ReactNode;
}
interface FilterListProps extends PropsWithChildren {
    value: IdentifierFilterValue[];
    onValueChange: (value: IdentifierFilterValue[]) => void;
    availableItems: FilterListItem[];
}
declare const FilterList: ({ value, onValueChange, availableItems }: FilterListProps) => react_jsx_runtime.JSX.Element;

type FilterOperatorLabelProps = {
    operator: FilterOperator;
};
declare const FilterOperatorLabel: ({ operator }: FilterOperatorLabelProps) => react_jsx_runtime.JSX.Element;

interface FilterPopUpProps extends PopUpProps {
    name?: ReactNode;
    value?: FilterValue;
    onValueChange: (value: FilterValue) => void;
    onRemove: () => void;
}
interface FilterPopUpBaseProps extends PopUpProps {
    /**
     * The name of the object/column the filter is applied to
     */
    name?: ReactNode;
    operator: FilterOperator;
    onOperatorChange: (operator: FilterOperator) => void;
    onRemove: () => void;
    allowedOperators: FilterOperator[];
    operatorOverrides?: FilterOperator[];
    noParameterRequired?: boolean;
}
declare const FilterBasePopUp: react.ForwardRefExoticComponent<FilterPopUpBaseProps & react.RefAttributes<HTMLDivElement>>;
declare const TextFilterPopUp: react.ForwardRefExoticComponent<FilterPopUpProps & react.RefAttributes<HTMLDivElement>>;
declare const NumberFilterPopUp: react.ForwardRefExoticComponent<FilterPopUpProps & react.RefAttributes<HTMLDivElement>>;
declare const DateFilterPopUp: react.ForwardRefExoticComponent<FilterPopUpProps & react.RefAttributes<HTMLDivElement>>;
declare const DatetimeFilterPopUp: react.ForwardRefExoticComponent<FilterPopUpProps & react.RefAttributes<HTMLDivElement>>;
declare const BooleanFilterPopUp: react.ForwardRefExoticComponent<FilterPopUpProps & react.RefAttributes<HTMLDivElement>>;
interface TagsFilterPopUpProps extends FilterPopUpProps {
    tags: ReadonlyArray<{
        tag: string;
        label: string;
        display?: ReactNode;
    }>;
}
declare const TagsFilterPopUp: react.ForwardRefExoticComponent<TagsFilterPopUpProps & react.RefAttributes<HTMLDivElement>>;
interface TagsSingleFilterPopUpProps extends FilterPopUpProps {
    tags: ReadonlyArray<{
        tag: string;
        label: string;
        display?: ReactNode;
    }>;
}
declare const TagsSingleFilterPopUp: react.ForwardRefExoticComponent<TagsSingleFilterPopUpProps & react.RefAttributes<HTMLDivElement>>;
declare const GenericFilterPopUp: react.ForwardRefExoticComponent<FilterPopUpProps & react.RefAttributes<HTMLDivElement>>;
interface DataTypeFilterPopUpProps extends FilterPopUpProps {
    dataType: DataType;
    tags: ReadonlyArray<{
        tag: string;
        label: string;
        display?: ReactNode;
    }>;
    operatorOverrides?: FilterOperator[];
}
declare const FilterPopUp: react.ForwardRefExoticComponent<DataTypeFilterPopUpProps & react.RefAttributes<HTMLDivElement>>;

interface SortingListItem {
    id: string;
    label: string;
    dataType: DataType;
}
interface SortingListProps {
    sorting: ColumnSort[];
    onSortingChange: (sorting: ColumnSort[]) => void;
    availableItems: SortingListItem[];
}
declare const SortingList: ({ sorting, onSortingChange, availableItems }: SortingListProps) => react_jsx_runtime.JSX.Element;

type DurationJSON = {
    years: number;
    months: number;
    days: number;
    hours: number;
    minutes: number;
    seconds: number;
    milliseconds: number;
};
declare class Duration {
    readonly years: number;
    readonly months: number;
    readonly days: number;
    readonly hours: number;
    readonly minutes: number;
    readonly seconds: number;
    readonly milliseconds: number;
    constructor({ years, months, days, hours, minutes, seconds, milliseconds, }?: Partial<DurationJSON>);
    /** Date arithmetic */
    addTo(date: Date): Date;
    subtractFrom(date: Date): Date;
    /** Duration arithmetic */
    add(other: Duration): Duration;
    subtract(other: Duration): Duration;
    equals(other: Duration): boolean;
    toJSON(): DurationJSON;
    /** Static difference */
    static difference(start: Date, end: Date): Duration;
    private applyTo;
    private assertRanges;
    valueOf(): number;
}

declare const DateTimeFormat: readonly ["date", "time", "dateTime"];
type DateTimeFormat = typeof DateTimeFormat[number];
type DateTimePrecision = 'minute' | 'second' | 'millisecond';
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];
type ZonedParts = {
    year: number;
    month: number;
    day: number;
    hour: number;
    minute: number;
    second: number;
    millisecond: number;
};
declare function toZonedDate(date: Date, timeZone?: string): Date;
declare function toZonedDate(date: null, timeZone?: string): null;
declare function toZonedDate(date: Date | null, timeZone?: string): Date | null;
declare function fromZonedDate(date: Date, timeZone?: string): Date;
declare function fromZonedDate(date: null, timeZone?: string): null;
declare function fromZonedDate(date: Date | null, timeZone?: string): Date | null;
type FormatAbsoluteOptions = {
    timeZone?: string;
    is24HourFormat?: boolean;
};
declare function tryParseDate(dateValue: Date | string | number | undefined | null): Date | null;
declare function normalizeToDateOnly(date: Date): Date;
declare function normalizeDatetime(dateTime: Date): Date;
declare const DateUtils: {
    monthsList: readonly ["january", "february", "march", "april", "may", "june", "july", "august", "september", "october", "november", "december"];
    weekDayList: readonly ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];
    equalDate: (date1: Date, date2: Date) => boolean;
    isLastMillisecondOfDay: (date: Date) => boolean;
    daysInMonth: (year: number, monthIndex: number) => number;
    sameTime: (a: Date, b: Date, compareSeconds?: boolean, compareMilliseconds?: boolean) => boolean;
    withTime: (datePart: Date, timePart: Date) => Date;
    zonedParts: (date: Date, timeZone: string) => ZonedParts;
    toZonedDate: typeof toZonedDate;
    fromZonedDate: typeof fromZonedDate;
    formatAbsolute: (date: Date, locale: string, format: DateTimeFormat, { timeZone, is24HourFormat }?: FormatAbsoluteOptions) => string;
    formatRelative: (date: Date, locale: string) => string;
    addDuration: (date: Date, duration: Partial<DurationJSON>) => Date;
    subtractDuration: (date: Date, duration: Partial<DurationJSON>) => Date;
    between: (value: Date, startDate?: Date, endDate?: Date) => boolean;
    weeksForCalenderMonth: (date: Date, weekStart: WeekDay, weeks?: number) => Date[][];
    timesInSeconds: {
        readonly second: 1;
        readonly minute: 60;
        readonly hour: 3600;
        readonly day: 86400;
        readonly week: 604800;
        readonly monthImprecise: 2629800;
        readonly yearImprecise: 31557600;
    };
    toInputString: (date: Date, format: DateTimeFormat, precision?: DateTimePrecision, isLocalTime?: boolean) => string;
    tryParseDate: typeof tryParseDate;
    toOnlyDate: typeof normalizeToDateOnly;
    toDateTimeOnly: typeof normalizeDatetime;
};

type DayPickerProps = Partial<FormFieldDataHandling<Date>> & {
    initialValue?: Date;
    displayedMonth?: Date;
    changeDisplayedMonth?: (date: Date) => void;
    initialDisplayedMonth?: Date;
    start?: Date;
    end?: Date;
    weekStart?: WeekDay;
    markToday?: boolean;
    className?: string;
};
/**
 * A component for selecting a day of a month
 */
declare const DayPicker: ({ displayedMonth: controlledDisplayedMonth, initialDisplayedMonth, changeDisplayedMonth, value: controlledValue, initialValue, start: providedStart, end: providedEnd, onValueChange, onEditComplete, weekStart, markToday, className, }: DayPickerProps) => react_jsx_runtime.JSX.Element;

type YearMonthPickerProps = Partial<FormFieldDataHandling<Date>> & {
    initialValue?: Date;
    start?: Date;
    end?: Date;
    className?: string;
};
declare const YearMonthPicker: ({ value: controlledValue, initialValue, start, end, onValueChange, onEditComplete, className, }: YearMonthPickerProps) => react_jsx_runtime.JSX.Element;

type DisplayMode = 'yearMonth' | 'day';
interface DatePickerProps extends Partial<FormFieldDataHandling<Date>>, Pick<DayPickerProps, 'markToday' | 'start' | 'end' | 'weekStart'> {
    initialValue?: Date;
    initialDisplay?: DisplayMode;
    dayPickerProps?: Omit<DayPickerProps, 'displayedMonth' | 'onChange' | 'selected' | 'weekStart' | 'markToday' | 'start' | 'end'>;
    yearMonthPickerProps?: Omit<YearMonthPickerProps, 'displayedYearMonth' | 'onChange' | 'start' | 'end'>;
    className?: string;
}
/**
 * A Component for picking a date
 */
declare const DatePicker: ({ value: controlledValue, initialValue, start, end, initialDisplay, weekStart, onValueChange, onEditComplete, yearMonthPickerProps, dayPickerProps, className }: DatePickerProps) => react_jsx_runtime.JSX.Element;

type TimePickerMinuteIncrement = '1min' | '5min' | '10min' | '15min' | '30min';
type TimePickerSecondIncrement = '1s' | '5s' | '10s' | '15s' | '30s';
type TimePickerMillisecondIncrement = '1ms' | '5ms' | '10ms' | '25ms' | '50ms' | '100ms' | '250ms' | '500ms';
interface TimePickerProps extends Partial<FormFieldDataHandling<Date>> {
    initialValue?: Date;
    is24HourFormat?: boolean;
    precision?: DateTimePrecision;
    minuteIncrement?: TimePickerMinuteIncrement;
    secondIncrement?: TimePickerSecondIncrement;
    millisecondIncrement?: TimePickerMillisecondIncrement;
    className?: string;
}
declare const TimePicker: ({ value: controlledValue, initialValue, onValueChange, onEditComplete, is24HourFormat: is24HourFormatOverride, minuteIncrement, secondIncrement, millisecondIncrement, precision, className, }: TimePickerProps) => react_jsx_runtime.JSX.Element;

interface TimeInputProps extends Partial<FormFieldDataHandling<Date>> {
    initialValue?: Date;
    is24HourFormat?: boolean;
    allowLooping?: boolean;
    precision?: DateTimePrecision;
    minuteIncrement?: TimePickerMinuteIncrement;
    secondIncrement?: TimePickerSecondIncrement;
    millisecondIncrement?: TimePickerMillisecondIncrement;
    className?: string;
}
/**
 * A time input built from vertical number stepper fields
 */
declare const TimeInput: ({ value: controlledValue, initialValue, onValueChange, onEditComplete, is24HourFormat: is24HourFormatOverride, minuteIncrement, secondIncrement, millisecondIncrement, precision, allowLooping, className, }: TimeInputProps) => react_jsx_runtime.JSX.Element;

interface DateTimePickerProps extends HTMLAttributes<HTMLDivElement>, Partial<FormFieldDataHandling<Date>>, Pick<DatePickerProps, 'start' | 'end' | 'weekStart' | 'markToday'>, Pick<TimeInputProps, 'is24HourFormat' | 'minuteIncrement' | 'secondIncrement' | 'millisecondIncrement' | 'precision'> {
    initialValue?: Date;
    mode?: DateTimeFormat;
    datePickerProps?: Omit<DatePickerProps, 'onChange' | 'value' | 'start' | 'end' | 'markToday'>;
    timeInputProps?: Omit<TimeInputProps, 'value' | 'onValueChange' | 'onEditComplete' | 'is24HourFormat' | 'minuteIncrement' | 'secondIncrement' | 'millisecondIncrement' | 'precision'>;
}
/**
 * A Component for picking a Date and Time
 */
declare const DateTimePicker: ({ value: controlledValue, initialValue, start, end, mode, is24HourFormat, minuteIncrement, weekStart, secondIncrement, millisecondIncrement, precision, onValueChange, onEditComplete, timeInputProps, datePickerProps, ...props }: DateTimePickerProps) => react_jsx_runtime.JSX.Element;

interface DateTimePickerDialogProps extends HTMLAttributes<HTMLDivElement>, Partial<FormFieldDataHandling<Date | null>>, Pick<DateTimePickerProps, 'start' | 'end' | 'weekStart' | 'markToday' | 'is24HourFormat' | 'minuteIncrement' | 'secondIncrement' | 'millisecondIncrement' | 'precision'> {
    initialValue?: Date | null;
    allowRemove?: boolean;
    pickerProps?: Omit<DateTimePickerProps, 'value' | 'onValueChange' | 'onEditComplete' | 'start' | 'end' | 'weekStart' | 'markToday' | 'is24HourFormat' | 'minuteIncrement' | 'secondIncrement' | 'millisecondIncrement' | 'precision'>;
    mode?: DateTimeFormat;
    label?: ReactNode;
    labelId?: string;
}
declare const DateTimePickerDialog: ({ initialValue, value, allowRemove, onValueChange, onEditComplete, mode, pickerProps, start, end, weekStart, markToday, is24HourFormat, minuteIncrement, secondIncrement, millisecondIncrement, precision, labelId, label, ...props }: DateTimePickerDialogProps) => react_jsx_runtime.JSX.Element;

type TimeDisplayMode = 'daysFromToday' | 'date' | 'time';
type TimeDisplayProps = {
    date: Date;
    mode?: TimeDisplayMode;
    is24HourFormat?: boolean;
    timeZone?: string;
};
declare const TimeDisplay: ({ date, mode, is24HourFormat: is24HourFormatOverride, timeZone: timeZoneOverride, }: TimeDisplayProps) => react_jsx_runtime.JSX.Element;

interface DateTimeFieldProps extends Partial<FormFieldInteractionStates>, Partial<FormFieldDataHandling<Date | null>>, Omit<HTMLAttributes<HTMLDivElement>, 'defaultValue' | 'onChange'> {
    initialValue?: Date | null;
    mode?: DateTimeFormat;
    precision?: DateTimePrecision;
    is24HourFormat?: boolean;
    locale?: string;
}
declare const DateTimeField: react.ForwardRefExoticComponent<DateTimeFieldProps & react.RefAttributes<HTMLDivElement>>;

interface DateTimeInputProps extends Partial<FormFieldInteractionStates>, Omit<HTMLAttributes<HTMLDivElement>, 'defaultValue' | 'onChange'>, Partial<FormFieldDataHandling<Date | null>>, Pick<DateTimePickerProps, 'start' | 'end' | 'weekStart' | 'markToday' | 'is24HourFormat' | 'minuteIncrement' | 'secondIncrement' | 'millisecondIncrement' | 'precision'> {
    initialValue?: Date | null;
    allowRemove?: boolean;
    allowClear?: boolean;
    mode?: DateTimeFormat;
    timeZone?: string;
    containerProps?: HTMLAttributes<HTMLDivElement>;
    pickerProps?: Omit<DateTimePickerProps, keyof FormFieldDataHandling<Date> | 'mode' | 'initialValue' | 'start' | 'end' | 'weekStart' | 'markToday' | 'is24HourFormat' | 'minuteIncrement' | 'secondIncrement' | 'millisecondIncrement' | 'precision'>;
    outsideClickCloses?: boolean;
    onDialogOpeningChange?: (isOpen: boolean) => void;
    actions?: ReactNode[];
}
declare const DateTimeInput: react.ForwardRefExoticComponent<DateTimeInputProps & react.RefAttributes<HTMLDivElement>>;

interface FlexibleDateTimeInputProps extends Omit<DateTimeInputProps, 'mode'> {
    defaultMode: Exclude<DateTimeFormat, 'time'>;
    fixedTime?: Date | null;
}
declare const FlexibleDateTimeInput: react.ForwardRefExoticComponent<FlexibleDateTimeInputProps & react.RefAttributes<HTMLDivElement>>;

/**
 * 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>>;

type NumberInputProps = Omit<InputHTMLAttributes<HTMLInputElement>, 'value' | 'type' | 'min' | 'max' | 'step'> & Partial<FormFieldInteractionStates> & Partial<FormFieldDataHandling<number>> & {
    initialValue?: number;
    minimum?: number;
    maximum?: number;
    approximateMaxCharacters?: number;
    formatDisplayedValue?: (value: number) => string;
    parseDisplayedValue?: (rawValue: string) => number | undefined;
};
/**
 * A number input with configurable width and range validation
 *
 * Its state is managed by the parent
 */
declare const NumberInput: react.ForwardRefExoticComponent<Omit<InputHTMLAttributes<HTMLInputElement>, "max" | "min" | "type" | "value" | "step"> & Partial<FormFieldInteractionStates> & Partial<FormFieldDataHandling<number>> & {
    initialValue?: number;
    minimum?: number;
    maximum?: number;
    approximateMaxCharacters?: number;
    formatDisplayedValue?: (value: number) => string;
    parseDisplayedValue?: (rawValue: string) => number | undefined;
} & react.RefAttributes<HTMLInputElement>>;

type Range = [number, number];
type UnBoundedRange = [undefined | number, undefined | number];
type DirectionNumber = 1 | -1;
type LoopingRangeBound = 'maximum' | 'minimum';
type LoopingRangeResult = {
    value: number;
    loopedOver: LoopingRangeBound | null;
};
declare function clamp(value: number, min: number | undefined, max: number | undefined): number;
declare function clamp01(value: number): number;
declare function closestStep(value: number, stepSize: number): number;
declare function toStepRange(value: number, stepSize: number, min: number | undefined, max: number | undefined): number;
declare function resolveLoopingRangeValue(value: number, minimum: number, maximum: number): LoopingRangeResult;
declare const MathUtil: {
    clamp: typeof clamp;
    clamp01: typeof clamp01;
    toStepRange: typeof toStepRange;
    closestStep: typeof closestStep;
    resolveLoopingRangeValue: typeof resolveLoopingRangeValue;
};

interface StepperLoopEvent {
    value: number;
    direction: DirectionNumber;
    loopedAround: 'maximum' | 'minimum';
}
type ChangeRateCurveProps = {
    multiplier?: number;
    minimum?: number;
    maximum?: number;
};
type UseStepperHoldOptions = {
    disabled?: boolean;
    minimum?: number;
    maximum?: number;
    isLooping?: boolean;
    value: number;
    stepSize?: number;
    stepTime?: number;
    changeRateCurveProps?: ChangeRateCurveProps;
    onValueChange: (value: number) => void;
    onLooped?: (event: StepperLoopEvent) => void;
};
declare function useStepperHold({ disabled, minimum, maximum, isLooping: looping, value, stepSize, stepTime, changeRateCurveProps, onValueChange, onLooped, }: UseStepperHoldOptions): {
    startHold: (direction: DirectionNumber) => void;
    stopHold: () => void;
};

type NumberStepperInputLayout = 'row' | 'col';
type NumberStepperInputProps = Omit<InputHTMLAttributes<HTMLInputElement>, 'value' | 'type' | 'min' | 'max' | 'step'> & Partial<FormFieldInteractionStates> & Partial<FormFieldDataHandling<number>> & {
    initialValue?: number;
    minimum?: number;
    maximum?: number;
    stepSize?: number;
    layout?: NumberStepperInputLayout;
    looping?: boolean;
    approximateMaxCharacters?: number;
    changeRateCurveProps?: ChangeRateCurveProps;
    formatDisplayedValue?: (value: number) => string;
    parseDisplayedValue?: (rawValue: string) => number | undefined;
    onLooped?: (event: StepperLoopEvent) => void;
    plusButtonClassName?: string;
    minusButtonClassName?: string;
};
/**
 * A number input with increment and decrement buttons
 *
 * Its state is managed by the parent
 */
declare const NumberStepperInput: react.ForwardRefExoticComponent<Omit<InputHTMLAttributes<HTMLInputElement>, "max" | "min" | "type" | "value" | "step"> & Partial<FormFieldInteractionStates> & Partial<FormFieldDataHandling<number>> & {
    initialValue?: number;
    minimum?: number;
    maximum?: number;
    stepSize?: number;
    layout?: NumberStepperInputLayout;
    looping?: boolean;
    approximateMaxCharacters?: number;
    changeRateCurveProps?: ChangeRateCurveProps;
    formatDisplayedValue?: (value: number) => string;
    parseDisplayedValue?: (rawValue: string) => number | undefined;
    onLooped?: (event: StepperLoopEvent) => void;
    plusButtonClassName?: string;
    minusButtonClassName?: string;
} & react.RefAttributes<HTMLInputElement>>;

type SearchBarProps = Omit<InputProps, 'onValueChange' | 'onEditComplete'> & {
    onValueChange?: (value: string) => void;
    onSearch: (value: string) => void;
    searchButtonProps?: Omit<IconButtonProps, 'onClick'>;
    containerProps?: HTMLAttributes<HTMLDivElement>;
};
declare const SearchBar: ({ value: controlledValue, initialValue, onValueChange, onSearch, searchButtonProps, containerProps, ...inputProps }: SearchBarProps) => react_jsx_runtime.JSX.Element;

/**
 * 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<react.InputHTMLAttributes<HTMLInputElement>, "value"> & Partial<FormFieldDataHandling<string>> & Partial<FormFieldInteractionStates> & {
    editCompleteOptions?: EditCompleteOptions;
    initialValue?: string;
    'data-name'?: string;
} & {
    initialState?: "editing" | "display";
    editCompleteOptions?: Omit<EditCompleteOptions, "allowEnterComplete">;
} & react.RefAttributes<HTMLInputElement>>;

declare const editableSegmentTypes: readonly ["day", "month", "year", "hour", "minute", "second", "millisecond", "dayPeriod"];
type EditableSegmentType = typeof editableSegmentTypes[number];
type DateTimeSegment = {
    kind: 'literal';
    text: string;
} | {
    kind: 'editable';
    type: EditableSegmentType;
};
type SegmentValues = Partial<Record<EditableSegmentType, number>>;
type SegmentBuffer = {
    type: EditableSegmentType;
    text: string;
};
type SegmentEditState = {
    values: SegmentValues;
    buffer: SegmentBuffer | null;
};
type SegmentBounds = {
    min: number;
    max: number;
};
type SegmentLayoutOptions = {
    locale: string;
    mode: DateTimeFormat;
    precision: DateTimePrecision;
    is24HourFormat: boolean;
};
declare const timeUnitTranslationKey: {
    readonly day: "time.day";
    readonly month: "time.month";
    readonly year: "time.year";
    readonly hour: "time.hour";
    readonly minute: "time.minute";
    readonly second: "time.second";
    readonly millisecond: "time.millisecond";
};
declare const segmentBounds: (type: EditableSegmentType, values: SegmentValues, is24HourFormat: boolean) => SegmentBounds;
declare const buildSegmentLayout: ({ locale, mode, precision, is24HourFormat }: SegmentLayoutOptions) => DateTimeSegment[];
declare const editableTypesOf: (layout: DateTimeSegment[]) => EditableSegmentType[];
declare const isComplete: (values: SegmentValues, layout: DateTimeSegment[]) => boolean;
declare const isEmpty: (values: SegmentValues, layout: DateTimeSegment[]) => boolean;
declare const decomposeDate: (date: Date, layout: DateTimeSegment[], is24HourFormat: boolean) => SegmentValues;
declare const composeDate: (values: SegmentValues, layout: DateTimeSegment[], mode: DateTimeFormat, is24HourFormat: boolean, reference?: Date) => Date | null;
declare const typeDigit: (state: SegmentEditState, type: EditableSegmentType, digit: number, is24HourFormat: boolean) => {
    state: SegmentEditState;
    advance: boolean;
};
declare const stepSegment: (state: SegmentEditState, type: EditableSegmentType, delta: number, is24HourFormat: boolean) => SegmentEditState;
declare const clearSegment: (state: SegmentEditState, type: EditableSegmentType) => SegmentEditState;
declare const setDayPeriod: (state: SegmentEditState, period: number) => SegmentEditState;
declare const segmentPlaceholder: (type: EditableSegmentType, locale: string) => string;
declare const formatSegment: (type: EditableSegmentType, values: SegmentValues, buffer: SegmentBuffer | null, locale: string) => string;

type PropertyField<T> = {
    name: string;
    required?: boolean;
    readOnly?: boolean;
    allowClear?: boolean;
    value?: T;
    onRemove?: () => void;
    onValueClear?: () => void;
    onValueChange?: (value: T) => void;
    onEditComplete?: (value: T) => void;
};
type PropertyBaseProps = {
    children: (props: {
        required: boolean;
        hasValue: boolean;
        invalid: boolean;
    }) => ReactNode;
    name: string;
    required?: boolean;
    readOnly?: boolean;
    allowClear?: boolean;
    allowRemove?: boolean;
    hasValue: boolean;
    onRemove?: () => void;
    onValueClear?: () => void;
    icon?: ReactNode;
    className?: string;
};
/**
 * A component for showing a properties with uniform styling
 */
declare const PropertyBase: ({ name, children, required, hasValue, icon, readOnly, allowClear, allowRemove, onRemove, onValueClear, className, }: PropertyBaseProps) => react_jsx_runtime.JSX.Element;

type CheckboxPropertyProps = PropertyField<boolean>;
/**
 * An Input component for a boolean values
 */
declare const CheckboxProperty: ({ value, onValueChange, onEditComplete, readOnly, ...baseProps }: CheckboxPropertyProps) => react_jsx_runtime.JSX.Element;

type DatePropertyProps = Pick<PropertyField<Date | null>, 'name' | 'onRemove' | 'onValueClear'> & Omit<DateTimeInputProps, 'mode' | 'allowRemove'> & {
    type?: 'dateTime' | 'date';
    allowRemove?: boolean;
};
declare const DateProperty: ({ name, value, onValueChange, onEditComplete, onRemove, onValueClear, required, readOnly, allowClear, allowRemove, type, className, ...inputProps }: DatePropertyProps) => react_jsx_runtime.JSX.Element;

interface MultiSelectPropertyProps extends PropertyField<string[]>, PropsWithChildren {
}
/**
 * An Input for MultiSelect properties
 */
declare const MultiSelectProperty: ({ children, value, onValueChange, onEditComplete, ...props }: MultiSelectPropertyProps) => react_jsx_runtime.JSX.Element;

type NumberPropertyProps = PropertyField<number> & {
    suffix?: string;
};
/**
 * An Input for number properties
 */
declare const NumberProperty: ({ value, onValueChange, onEditComplete, onValueClear, readOnly, suffix, ...baseProps }: NumberPropertyProps) => react_jsx_runtime.JSX.Element;

interface SingleSelectPropertyProps extends PropertyField<string>, PropsWithChildren {
}
/**
 * An Input for SingleSelect properties
 */
declare const SingleSelectProperty: ({ children, value, onValueChange, onEditComplete, ...props }: SingleSelectPropertyProps) => react_jsx_runtime.JSX.Element;

type TextPropertyProps = PropertyField<string>;
/**
 * An Input for Text properties
 */
declare const TextProperty: ({ value, readOnly, onValueChange, onEditComplete, ...baseProps }: TextPropertyProps) => react_jsx_runtime.JSX.Element;

interface FocusTrapProps extends PropsWithChildren, UseFocusTrapProps {
}
declare const FocusTrap: ({ children, ...props }: FocusTrapProps) => react.ReactNode;
interface FocusTrapWrapperProps extends HTMLAttributes<HTMLDivElement>, Omit<FocusTrapProps, 'container'> {
}
/**
 * A wrapper for the useFocusTrap hook that directly renders it to a div
 */
declare const FocusTrapWrapper: react.ForwardRefExoticComponent<FocusTrapWrapperProps & react.RefAttributes<HTMLDivElement>>;

interface PortalProps extends PropsWithChildren {
    container?: HTMLElement;
}
declare const Portal: ({ children, container }: PortalProps) => react.ReactPortal;

type BagFunction<B, V = ReactNode> = (bag: B) => V;
type BagFunctionOrValue<B, V> = BagFunction<B, V> | V;
type BagFunctionOrNode<B> = BagFunction<B> | ReactNode;
type PropsWithBagFunction<B, P = unknown> = P & {
    children?: BagFunction<B>;
};
type PropsWithBagFunctionOrChildren<B, P = unknown> = P & {
    children?: BagFunctionOrNode<B>;
};
declare const BagFunctionUtil: {
    resolve: <B, V = ReactNode>(bagFunctionOrValue: BagFunctionOrValue<B, V>, bag: B) => V;
};

type TransitionBag = {
    isOpen: boolean;
    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): string | number | bigint | boolean | react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<react.ReactNode> | react.ReactPortal | Promise<string | number | bigint | boolean | react.ReactPortal | react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<react.ReactNode>>;

type LocaleWithSystem = HightideTranslationLocales | 'system';
type LocaleContextValue = {
    locale: HightideTranslationLocales;
    setLocale: Dispatch<SetStateAction<LocaleWithSystem>>;
    timeZone?: string;
    setTimeZone?: (timeZone: string | undefined) => void;
    is24HourFormat?: boolean;
    setIs24HourFormat?: (is24HourFormat: boolean | undefined) => void;
};
declare const LocaleContext: react.Context<LocaleContextValue>;
type LocaleProviderProps = PropsWithChildren & Partial<LocalizationConfig> & {
    locale?: LocaleWithSystem;
    onChangedLocale?: (locale: HightideTranslationLocales) => void;
    timeZone?: string;
    onChangedTimeZone?: (timeZone: string | undefined) => void;
    is24HourFormat?: boolean;
    onChangedIs24HourFormat?: (is24HourFormat: boolean) => void;
};
declare const LocaleProvider: ({ children, locale, defaultLocale, defaultTimeZone, defaultIs24HourFormat, timeZone, is24HourFormat, onChangedLocale, onChangedTimeZone, onChangedIs24HourFormat, }: LocaleProviderProps) => react_jsx_runtime.JSX.Element;
declare const useLocale: () => LocaleContextValue;
declare const useTimeZone: () => {
    timeZone: string;
    setTimeZone: (timeZone: string | undefined) => void;
};
declare const useDateTimeFormat: () => {
    is24HourFormat: boolean;
    timeZone: string;
};
declare const useLanguage: () => {
    language: string;
};

type HightideProviderProps = PropsWithChildren & {
    theme?: Omit<ThemeProviderProps, 'children'>;
    locale?: Omit<LocaleProviderProps, 'children'>;
    config?: Omit<HightideConfigProviderProps, 'children'>;
};
declare const HightideProvider: ({ children, theme, locale, config, }: HightideProviderProps) => react_jsx_runtime.JSX.Element;

declare const useFocusGuards: () => void;

declare function useFocusManagement(): {
    getFocusableElements: () => HTMLElement[];
    getNextFocusElement: () => HTMLElement | undefined;
    getPreviousFocusElement: () => HTMLElement | undefined;
    focusNext: () => void;
    focusPrevious: () => void;
};

declare const useFocusOnceVisible: (ref: RefObject<HTMLElement>, disable?: boolean) => void;

declare function buildTreeIndex(nodes: ReadonlyArray<TreeNode>): TreeIndex;
declare function resolveTreeNodePath(nodes: ReadonlyArray<TreeNode>, id: string | null): ReadonlyArray<string> | null;
declare function flattenAllItems(nodes: ReadonlyArray<TreeNode>, expandedIds: ReadonlySet<string>, path?: string[]): TreeItem[];
declare function flattenVisibleItems(nodes: ReadonlyArray<TreeNode>, expandedIds: ReadonlySet<string>, path?: string[]): TreeItem[];
declare function getExpandableAncestorIds(path: ReadonlyArray<string>, index: TreeIndex): string[];
declare function getDescendantIds(index: TreeIndex, id: string): string[];
declare function isAncestorOf(ancestorId: string, descendantPath: ReadonlyArray<string>): boolean;
declare function pruneExpandedIds(expandedIds: ReadonlySet<string>, focusedPath: ReadonlyArray<string> | null, onlyOneExpandedTree: boolean, index: TreeIndex): Set<string>;
declare function areExpandedIdsEqual(left: ReadonlySet<string>, right: ReadonlySet<string>): boolean;
declare function syncExpansionForFocused(expandedIds: ReadonlySet<string>, focusedPath: ReadonlyArray<string>, onlyOneExpandedTree: boolean, index: TreeIndex): ReadonlySet<string>;
declare const TreeUtilities: {
    areExpandedIdsEqual: typeof areExpandedIdsEqual;
    syncExpansionForFocused: typeof syncExpansionForFocused;
    buildTreeIndex: typeof buildTreeIndex;
    flattenAllItems: typeof flattenAllItems;
    flattenVisibleItems: typeof flattenVisibleItems;
    getDescendantIds: typeof getDescendantIds;
    getExpandableAncestorIds: typeof getExpandableAncestorIds;
    isAncestorOf: typeof isAncestorOf;
    pruneExpandedIds: typeof pruneExpandedIds;
};

interface TreeFocusNavigationOptions {
    nodes: ReadonlyArray<TreeNode>;
    visibleItems: ReadonlyArray<TreeItem>;
    focusedId?: string | null;
    onFocusedIdChange?: (focusedId: string | null) => void;
    initialFocusedId?: string | null;
    onNavigate?: (id: string, path: ReadonlyArray<string>) => void;
}
interface TreeFocusNavigationReturn {
    focusedId: string | null;
    focusedItem: TreeItem | null;
    setFocusedId: (focusedId: string | null) => void;
    navigateTo: (id: string) => void;
    next: () => void;
    previous: () => void;
    first: () => void;
    last: () => void;
}
declare function useTreeFocusNavigation({ nodes, visibleItems, focusedId: controlledFocusedId, onFocusedIdChange, initialFocusedId, onNavigate, }: TreeFocusNavigationOptions): TreeFocusNavigationReturn;

interface TreeNavigationOptions extends TreeExpansionOptions {
    focusedId?: string | null;
    onFocusedIdChange?: (focusedId: string | null) => void;
    initialFocusedId?: string | null;
}
interface TreeNavigationActionOptions {
    isFocusing?: boolean;
}
interface TreeNavigationReturn extends Omit<TreeExpansionReturn, 'expand' | 'collapse' | 'toggleExpansion'>, Omit<TreeFocusNavigationReturn, 'setFocusedId'> {
    expand: (id: string, options?: TreeNavigationActionOptions) => void;
    collapse: (id: string, options?: TreeNavigationActionOptions) => void;
    toggleExpansion: (id: string, options?: TreeNavigationActionOptions) => void;
}
declare function useTreeNavigation({ nodes, focusedId: controlledFocusedId, onFocusedIdChange, initialFocusedId, onlyOneExpandedTree, ...expansionOptions }: TreeNavigationOptions): TreeNavigationReturn;

type UseChangingNumberOptions = {
    start: number;
    end: number;
    animationTime?: number;
    curve?: Curve;
    resetRateAfterUpdate?: boolean;
};
declare function useChangingNumber({ start, end, animationTime, curve, resetRateAfterUpdate, }: UseChangingNumberOptions): number;

interface ControlledStateProps<T> {
    /**
     * The controlled value of the state.
     *
     * This is determines whether the state:
     * 1. (value !== undefined) => controlled
     * 2. (value === undefined) => uncontrolled
     *
     * If you need to include undefined as a valid state, you can set isControlled to true to force the component to be controlled.
     */
    value?: T;
    /** The callback whenever a setter changes the value */
    onValueChange?: (value: T) => void;
    /** The default value to use if the component is uncontrolled */
    defaultValue?: T;
    /** Forces the component to be controlled even if value is undefined */
    isControlled?: boolean;
}
declare const useControlledState: <T>({ value: controlledValue, onValueChange, defaultValue, isControlled: isEnforcingControlled }: ControlledStateProps<T>) => [T, react__default.Dispatch<react__default.SetStateAction<T>>, boolean];

declare function useDebouncer(debounceMs?: number): (callback: () => void, debounceMsOverride?: number) => void;

declare function useEventCallbackStabilizer<T extends (...args: any[]) => any>(callback?: T): (...args: Parameters<T>) => ReturnType<T>;

type ElementHandle = Record<string, HTMLElement | null>;
declare function useHandleRefs<T extends ElementHandle>(handleRef: RefObject<T>): RefObject<HTMLElement | null>[];

declare const useIsMounted: () => boolean;

interface ListNavigationReturn {
    highlightedId: string | null;
    highlight: (id: string) => void;
    first: () => void;
    last: () => void;
    next: () => void;
    previous: () => void;
}
interface ListNavigationOptions {
    options: ReadonlyArray<string>;
    value?: string | null;
    onValueChange?: (highlightedId: string | null) => void;
    initialValue?: string | null;
}
declare function useListNavigation({ options, value, onValueChange, initialValue, }: ListNavigationOptions): ListNavigationReturn;

type OptionsResolved = {
    type?: 'info' | 'error' | 'warning';
};
type Options = Partial<OptionsResolved>;
declare const useLogOnce: (message: string, condition: boolean, options?: Options) => void;

declare function useLogUnstableDependencies<T extends Record<string, unknown>>(name: string, value: T): void;

interface UseMultiSelectionOption {
    id: string;
    disabled?: boolean;
}
interface UseMultiSelectionOptions {
    options: ReadonlyArray<UseMultiSelectionOption>;
    value?: ReadonlyArray<string>;
    onSelectionChange?: (selection: ReadonlyArray<string>) => void;
    initialSelection?: ReadonlyArray<string>;
    isControlled?: boolean;
}
interface UseMultiSelectionReturn {
    selection: ReadonlyArray<string>;
    setSelection: (selection: ReadonlyArray<string>) => void;
    toggleSelection: (id: string) => void;
    isSelected: (id: string) => boolean;
}
declare function useMultiSelection({ options: optionsList, value, onSelectionChange, initialSelection, isControlled, }: UseMultiSelectionOptions): UseMultiSelectionReturn;

type OverlayItem = {
    id: string;
    tags?: string[];
};
type OverlayItemInformation = OverlayItem & {
    zIndex: number;
    position: number;
    tagPositions: Record<string, number>;
};
type OverlayRegistryValue = {
    itemInformation: Record<string, OverlayItemInformation>;
    tagItemCounts: Record<string, number>;
    activeId: string | null;
};
type OverlayRegistryListenerCallback = (value: OverlayRegistryValue) => void;
declare class OverlayRegistry {
    private static instance;
    static getInstance(): OverlayRegistry;
    private overlayIds;
    private overlayItems;
    private listeners;
    register(item: OverlayItem): () => void;
    update(item: OverlayItem): void;
    addListener(callback: OverlayRegistryListenerCallback): () => void;
    private notify;
}
type UseOverlayRegistryProps = Partial<OverlayItem> & {
    isActive?: boolean;
    /** Tags cannot change on every render, thus make sure they are wrapped in a useMemo or similar */
    tags?: string[];
};
type UseOverlayRegistryResult = {
    isInFront: boolean;
    zIndex?: number;
    position?: number;
    tagPositions?: Record<string, number>;
    tagItemCounts: Record<string, number>;
};
declare const useOverlayRegistry: (props?: UseOverlayRegistryProps) => UseOverlayRegistryResult;

declare const useOverwritableState: <T>(overwriteValue?: T, onChange?: (value: T) => void) => [T, react__default.Dispatch<react__default.SetStateAction<T>>];

interface UsePresenceRefProps {
    isOpen?: boolean;
}
declare const usePresenceRef: <T extends HTMLElement>({ isOpen, }: UsePresenceRefProps) => {
    isPresent: boolean;
    ref: react.RefObject<T>;
    refAssignment: (node: T | null) => void;
};

declare const useRerender: () => react.ActionDispatch<[]>;

type UseResizeObserverProps = {
    observedElementRef?: RefObject<Element | null>;
    onResize: () => void;
    isActive?: boolean;
};
declare function useResizeObserver({ observedElementRef, onResize, isActive }: UseResizeObserverProps): void;

type UseScrollObserverProps = {
    observedElementRef?: RefObject<HTMLElement | null>;
    onScroll: () => void;
    isActive?: boolean;
};
declare function useScrollObserver({ observedElementRef, onScroll, isActive }: UseScrollObserverProps): void;

type ScrollbarState = 'vertical' | 'horizontal' | 'both';
type UseScrollbarStateProps = {
    containerRef: RefObject<HTMLElement | null>;
    contentRef?: RefObject<HTMLElement | null>;
    isActive?: boolean;
};
declare function useScrollbarState({ containerRef, contentRef, isActive }: UseScrollbarStateProps): ScrollbarState;

interface UseSearchOptions<T> {
    items: ReadonlyArray<T>;
    searchQuery: string;
    toTags?: (value: T) => string[];
}
interface UseSearchReturn<T> {
    searchResult: ReadonlyArray<T>;
}
declare function useSearch<T>({ items, searchQuery, toTags, }: UseSearchOptions<T>): UseSearchReturn<T>;

interface SelectionOption {
    id: string;
    disabled?: boolean;
}
interface UseSingleSelectionOptions {
    options: ReadonlyArray<SelectionOption>;
    selection?: string | null;
    onSelectionChange?: (selection: string | null) => void;
    initialSelection?: string | null;
    isLooping?: boolean;
}
interface SingleSelectionReturn {
    selection: string | null;
    selectedIndex: number | null;
    selectByIndex: (index: number) => void;
    selectValue: (value: string | null) => void;
    selectFirst: () => void;
    selectLast: () => void;
    selectNext: () => void;
    selectPrevious: () => void;
}
declare function useSingleSelection({ options: optionsList, selection: controlledSelection, onSelectionChange, initialSelection, isLooping, }: UseSingleSelectionOptions): SingleSelectionReturn;

interface UseStorageProps<T> {
    key: string;
    defaultValue: T;
    storageType?: 'local' | 'session';
    serialize?: (value: T) => string;
    deserialize?: (value: string) => T;
    /** Whether to listen for storage events and update the value automatically. Defaults to true. */
    listen?: boolean;
}
interface UseStorageResult<T> {
    value: T;
    setValue: Dispatch<SetStateAction<T>>;
    deleteValue: () => void;
}
declare const useStorage: <T>({ key, defaultValue, storageType, serialize, deserialize, listen }: UseStorageProps<T>) => UseStorageResult<T>;

type SwipeInputMode = 'touch' | 'mouse' | 'both';
type SwipeDirection = 'leftToRight' | 'rightToLeft' | 'topToBottom' | 'bottomToTop';
interface SwipeEventData {
    direction: SwipeDirection;
}
interface SwipeStartRegion {
    minX?: number;
    maxX?: number;
    minY?: number;
    maxY?: number;
}
interface UseSwipeGestureOptions {
    elementRef?: RefObject<HTMLElement | null>;
    inputMode?: SwipeInputMode;
    onSwipe?: (data: SwipeEventData) => void;
    startRegion?: SwipeStartRegion;
    threshold?: number;
    crossAxisThreshold?: number;
    maxSwipeTime?: number;
}
declare const useSwipeGesture: ({ elementRef, inputMode, onSwipe, startRegion, threshold, crossAxisThreshold, maxSwipeTime, }: UseSwipeGestureOptions) => RefObject<HTMLElement>;

declare function useThrottle(throttleMs?: number): (callback: () => void, throttleMsOverride?: number) => void;

type TransitionState = 'opened' | 'closed' | 'opening' | 'closing';
type UseTransitionStateResult = {
    transitionState: TransitionState;
    isVisible: boolean;
};
type UseTransitionStateProps = {
    isOpen: boolean;
    initialState?: TransitionState;
    ref: RefObject<HTMLElement | null>;
    timeout?: number;
};
declare const useTransitionState: ({ isOpen, initialState, ref, timeout: initialTimeout, }: UseTransitionStateProps) => UseTransitionStateResult;

interface UseTypeAheadSearchOptions<T> {
    options: ReadonlyArray<T>;
    resetTimer: number;
    toString?: (value: T) => string;
    onResultChange: (value: T | null) => void;
}
interface UseTypeAheadSearchReturn {
    addToTypeAhead: (str: string) => void;
    reset: () => void;
}
declare function useTypeAheadSearch<T>({ options, resetTimer, toString: toStringProp, onResultChange, }: UseTypeAheadSearchOptions<T>): UseTypeAheadSearchReturn;

interface UseUpdatingDateStringProps {
    date: Date;
    absoluteFormat?: DateTimeFormat;
    localeOverride?: HightideTranslationLocales;
    is24HourFormat?: boolean;
    timeZone?: string;
}
declare const useUpdatingDateString: ({ absoluteFormat, localeOverride, is24HourFormat: is24HourFormatOverride, timeZone: timeZoneOverride, date }: UseUpdatingDateStringProps) => {
    absolute: string;
    relative: 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 | undefined) => string;
    selection: (value: unknown[] | undefined, length: [number | undefined, number | undefined]) => string;
};

/**
 * 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 useWindowResizeObserver: (onResize: () => void) => void;

/**
 * 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;
    languagesLocalNames: Record<"de-DE" | "en-US", string>;
};

type StorageSubscriber = (raw: string | null) => void;
declare class StorageListener {
    private static instance;
    private localSubscriptions;
    private sessionSubscriptions;
    private initialized;
    private constructor();
    static getInstance(): StorageListener;
    subscribe(storage: Storage, key: string, cb: StorageSubscriber): () => void;
    private init;
    private handleEvent;
    private getRegistry;
}

declare const equalSizeGroups: <T>(array: T[], groupSize: number) => T[][];
type RangeOptions = {
    /**  Whether the range can be defined empty via end < start without a warning */
    allowEmptyRange: boolean;
    stepSize: number;
    exclusiveStart: boolean;
    exclusiveEnd: boolean;
};
/**
 * @param endOrRange The end value or a range [start, end], end is exclusive
 * @param options the options for defining the range
 */
declare const range: (endOrRange: number | [number, number], options?: Partial<RangeOptions>) => number[];
/** Finds the closest match
 * @param list The list of all possible matches
 * @param firstCloser Return whether item1 is closer than item2
 */
declare const closestMatch: <T>(list: T[], firstCloser: (item1: T, item2: T) => boolean) => T;
/**
 * returns the item in middle of a list and its neighbours before and after
 * e.g. [1,2,3,4,5,6] for item = 1 would return [5,6,1,2,3]
 */
declare const getNeighbours: <T>(list: T[], item: T, neighbourDistance?: number) => T[];
declare const createLoopingListWithIndex: <T>(list: T[], startIndex?: number, length?: number, forwards?: boolean) => [number, T][];
declare const createLoopingList: <T>(list: T[], startIndex?: number, length?: number, forwards?: boolean) => T[];
declare function resolveSingleOrArray<T>(value: T | T[]): T[];
declare const ArrayUtil: {
    unique: <T>(list: T[]) => T[];
    difference: <T>(list: T[], removeList: T[]) => T[];
    moveItems: <T>(list: T[], move?: number) => any[];
    resolveSingleOrArray: typeof resolveSingleOrArray;
};

/**
 * A simple function that implements the builder pattern
 * @param value The value to update which gets return with the same reference
 * @param update The updates to apply on the object
 */
declare const builder: <T>(value: T, update: (value: T) => void) => T;

declare function compareDocumentPosition(a: Node | null | undefined, b: Node | null | undefined): 0 | 1 | -1;
declare const DOMUtils: {
    compareDocumentPosition: typeof compareDocumentPosition;
};

declare const validateEmail: (email: string) => boolean;

/**
 *  1 is forwards
 *
 * -1 is backwards
 */
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: DirectionNumber): number;
    getDistanceForward(position: number, target: number): number;
    getDistanceBackward(position: number, target: number): number;
    getDistance(position: number, target: number): number;
    getBestDirection(position: number, target: number): DirectionNumber;
}

declare const match: <K extends string | number | symbol, V>(key: K, values: Record<K, V>) => Record<K, V>[K];

declare const noop: () => any;

declare function sleep(ms: number): Promise<void>;
declare function delayed<T>(value: T, ms: number): Promise<T>;
declare const PromiseUtils: {
    sleep: typeof sleep;
    delayed: typeof delayed;
};

declare function bool(isActive: boolean): string | undefined;
type InteractionStateDataAttributes = {
    'data-disabled': string | undefined;
    'data-invalid': string | undefined;
    'data-readonly': string | undefined;
    'data-required': string | undefined;
};
declare function interactionStatesData(interactionStates: Partial<FormFieldInteractionStates>): Partial<InteractionStateDataAttributes>;
type MouseEventExtenderProps<T> = {
    fromProps?: react__default.MouseEventHandler<T>;
    extensions: SingleOrArray<react__default.MouseEventHandler<T>>;
};
declare function mouseEventExtender<T>({ fromProps, extensions }: MouseEventExtenderProps<T>): react__default.MouseEventHandler<T>;
type KeyoardEventExtenderProps<T> = {
    fromProps: react__default.KeyboardEventHandler<T>;
    extensions: SingleOrArray<react__default.KeyboardEventHandler<T>>;
};
declare function keyboardEventExtender<T>({ fromProps, extensions, }: KeyoardEventExtenderProps<T>): react__default.KeyboardEventHandler<T>;
declare function click<T>(onClick: () => void): {
    onClick: () => void;
    onKeyDown: react__default.KeyboardEventHandler<T>;
};
declare function close<T>(onClose?: () => void): react__default.KeyboardEventHandler<T>;
type NavigateType<T> = {
    left?: (event: react__default.KeyboardEvent<T>) => void;
    right?: (event: react__default.KeyboardEvent<T>) => void;
    up?: (event: react__default.KeyboardEvent<T>) => void;
    down?: (event: react__default.KeyboardEvent<T>) => void;
};
declare function navigate<T>({ left, right, up, down, }: NavigateType<T>): react__default.KeyboardEventHandler<T>;
declare function mergeProps<T extends object, U extends Partial<T>>(slotProps: T, childProps: U): T & U;
type InteractionStateARIAAttributes = Pick<HTMLAttributes<HTMLDivElement>, 'aria-disabled' | 'aria-invalid' | 'aria-readonly' | 'aria-required'>;
declare function interactionStatesAria(interactionStates: Partial<FormFieldInteractionStates>, props?: Partial<InteractionStateARIAAttributes>): Partial<InteractionStateARIAAttributes>;
declare const PropsUtil: {
    extender: {
        mouseEvent: typeof mouseEventExtender;
        keyboardEvent: typeof keyboardEventExtender;
    };
    dataAttributes: {
        bool: typeof bool;
        interactionStates: typeof interactionStatesData;
    };
    aria: {
        close: typeof close;
        click: typeof click;
        navigate: typeof navigate;
        interactionStates: typeof interactionStatesAria;
    };
    mergeProps: typeof mergeProps;
};

declare function assignForwardRef<T>(element: T | null, ref?: ForwardedRef<T>): void;
declare function assingRefsBuilder<T>(refs: ForwardedRef<T>[]): (el: T | null) => void;
declare const ReactRefsUtil: {
    assignForwardRef: typeof assignForwardRef;
    assingRefsBuilder: typeof assingRefsBuilder;
};

declare function resolveSetState<T>(action: SetStateAction<T>, prev: T): T;

/**
 *  Finds all values matching the search values by first mapping the values to a string array and then checking each entry for matches.
 *  Returns the list of all matches.
 *
 *  @param search The list of search strings e.g. `[name, type]`
 *
 *  @param objects The list of objects to be searched in
 *
 *  @param mapping The mapping of objects to the string properties they fulfil
 *
 *  @return The list of objects that match all search strings
 */
declare const MultiSubjectSearchWithMapping: <T>(search: string[], objects: T[], mapping: (value: T) => (string[] | undefined)) => T[];
/**
 *  Finds all values matching the search value by first mapping the values to a string array and then checking each entry for matches.
 *  Returns the list of all matches.
 *
 *  @param search The search string e.g `name`
 *
 *  @param objects The list of objects to be searched in
 *
 *  @param mapping The mapping of objects to the string properties they fulfil, if undefined it is always fulfilled
 *
 *  @return The list of objects that match the search string
 */
declare const MultiSearchWithMapping: <T>(search: string, objects: T[], mapping: (value: T) => (string[] | undefined)) => T[];
/**
 *  Finds all values matching the search value by first mapping the values to a string and returns the list of all matches.
 *
 *  @param search The search string e.g `name`
 *
 *  @param objects The list of objects to be searched in
 *
 *  @param mapping The mapping of objects to a string that is compared to the search
 *
 *  @return The list of objects that match the search string
 */
declare const SimpleSearchWithMapping: <T>(search: string, objects: T[], mapping: (value: T) => string) => T[];
/**
 *  Finds all values matching the search value and returns the list of all matches.
 *
 *  @param search The search string e.g `name`
 *
 *  @param objects The list of objects to be searched in
 *
 *  @return The list of objects that match the search string
 */
declare const SimpleSearch: (search: string, objects: string[]) => string[];

declare const writeToClipboard: (text: string) => Promise<void>;

export { APP_PAGE_CONTENT_SELECTOR, ASTNodeInterpreter, type ASTNodeInterpreterProps, ActionCard, type ActionCardProps, AnchoredFloatingContainer, type AnchoredFloatingContainerProps, AppPage, type AppPageNavigationItem, type AppPageProps, type AppPageSidebarProps, AppPageSidebarWithNavigation, type AppPageSidebarWithNavigationProps, AppSidebar, type AppSidebarProps, AppZumDocBadge, type AppZumDocBadgeProps, AppZumDocLogo, type AppZumDocLogoProps, ArrayUtil, AutoColumnOrderFeature, Avatar, AvatarGroup, type AvatarGroupProps, type AvatarImageProps, type AvatarProps, type AvatarSize, type AvatarStatus, AvatarWithLabel, type AvatarWithLabelProps, AvatarWithStatus, type AvatarWithStatusProps, type BackgroundOverlayProps, type BagFunction, type BagFunctionOrNode, type BagFunctionOrValue, BagFunctionUtil, BooleanFilterPopUp, BreadCrumbGroup, BreadCrumbLink, type BreadCrumbLinkElementProps, type BreadCrumbLinkProps, type BreadCrumbProps, BreadCrumbs, Button, type ButtonColor, type ButtonProps, ButtonUtil, Card, type CardProps, type CardSize, Carousel, type CarouselProps, CarouselSlide, type CarouselSlideProps, type ChangeRateCurveProps, ChangingNumber, type ChangingNumberProps, ChatAttachmentCard, type ChatAttachmentCardProps, ChatConversationList, type ChatConversationListProps, ChatConversationRow, type ChatConversationRowProps, type ChatConversationSentIndicator, ChatDateDivider, type ChatDateDividerProps, ChatMessageBubble, type ChatMessageBubbleProps, ChatMessageCard, type ChatMessageCardProps, ChatMessageComposer, type ChatMessageComposerProps, type ChatMessageDirection, ChatMessageList, type ChatMessageListProps, ChatQuickReplyChip, type ChatQuickReplyChipProps, ChatSystemLine, type ChatSystemLineProps, ChatThreadHeader, type ChatThreadHeaderProps, Checkbox, CheckboxProperty, type CheckboxPropertyProps, type CheckboxProps, Chip, type ChipColor, ChipList, type ChipListProps, type ChipProps, ChipUtil, type ColumnSizeCalculatoProps, ColumnSizeUtil, type ColumnSizingMode, ColumnSizingWithTargetFeature, Combobox, ComboboxContext, type ComboboxContextActions, type ComboboxContextComputedState, type ComboboxContextConfig, type ComboboxContextIds, type ComboboxContextInternalState, type ComboboxContextLayout, type ComboboxContextSearch, type ComboboxContextType, ComboboxInput, type ComboboxInputProps, ComboboxList, type ComboboxListProps, ComboboxOption, type ComboboxOptionProps, type ComboboxOptionType, type ComboboxProps, ComboboxRoot, type ComboboxRootProps, ConfirmDialog, type ConfirmDialogProps, type ConfirmDialogType, type ControlledStateProps, CopyToClipboardWrapper, type CopyToClipboardWrapperProps, type Crumb, type CubicBezierCurveBuilder, type Curve, CurveBuilderUtil, DOMUtils, type DataType, type DataTypeFilterPopUpProps, DataTypeUtils, type DataValue, DateFilterPopUp, DatePicker, type DatePickerProps, DateProperty, type DatePropertyProps, DateTimeField, type DateTimeFieldProps, DateTimeFormat, DateTimeInput, type DateTimeInputProps, DateTimePicker, DateTimePickerDialog, type DateTimePickerDialogProps, type DateTimePickerProps, type DateTimePrecision, type DateTimeSegment, DateUtils, DatetimeFilterPopUp, DayPicker, type DayPickerProps, type DeepPartial, Dialog, DialogContext, type DialogContextType, type DialogOpenerPassingProps, DialogOpenerWrapper, type DialogOpenerWrapperBag, type DialogOpenerWrapperProps, type DialogPosition, type DialogProps, DialogRoot, type DialogRootProps, type DirectionNumber, DiscardChangesDialog, DividerInserter, type DividerInserterProps, Drawer, type DrawerAligment, DrawerCloseButton, type DrawerCloseButtonProps, DrawerContainer, type DrawerContainerProps, DrawerContext, type DrawerContextType, type DrawerProps, DrawerRoot, type DrawerRootProps, Duration, type DurationJSON, type EditCompleteOptions, type EditCompleteOptionsResolved, type EditableSegmentType, type ElementHandle, ErrorComponent, type ErrorComponentProps, type Exact, Expandable, ExpandableContent, type ExpandableContentProps, ExpandableHeader, type ExpandableHeaderProps, type ExpandableProps, ExpandableRoot, type ExpandableRootProps, ExpansionIcon, type ExpansionIconProps, type ExponentialCurveBuilderProps, type ExponentialCurveBuilderPropsResolved, type ExponentialRateCurveBuilder, type FAQItem, FAQSection, type FAQSectionProps, FillerCell, type FillerCellProps, FilterBasePopUp, FilterFunctions, FilterList, type FilterListItem, type FilterListPopUpBuilderProps, type FilterListProps, type FilterOperator, type FilterOperatorBoolean, type FilterOperatorDate, type FilterOperatorDatetime, FilterOperatorLabel, type FilterOperatorLabelProps, type FilterOperatorNumber, type FilterOperatorTags, type FilterOperatorTagsSingle, type FilterOperatorText, type FilterOperatorUnknownType, FilterOperatorUtils, type FilterParameter, FilterPopUp, type FilterPopUpBaseProps, type FilterPopUpProps, type FilterValue, type FilterValueTranslationOptions, FilterValueUtils, FlexibleDateTimeInput, type FlexibleDateTimeInputProps, type FloatingElementAlignment, FocusTrap, type FocusTrapProps, FocusTrapWrapper, type FocusTrapWrapperProps, FormContext, type FormContextType, type FormEvent, type FormEventListener, FormField, type FormFieldAriaAttributes, type FormFieldBag, type FormFieldDataHandling, type FormFieldFocusableElementProps, type FormFieldInteractionStates, FormFieldLayout, type FormFieldLayoutBag, type FormFieldLayoutIds, type FormFieldLayoutProps, type FormFieldProps, type FormFieldResult, FormObserver, FormObserverKey, type FormObserverKeyProps, type FormObserverKeyResult, type FormObserverProps, type FormObserverResult, FormProvider, type FormProviderProps, FormStore, type FormStoreProps, type FormValidationBehaviour, type FormValidator, type FormValue, GenericFilterPopUp, HelpwaveBadge, type HelpwaveBadgeProps, HelpwaveLogo, type HelpwaveProps, type HightideConfig, HightideConfigContext, HightideConfigProvider, type HightideConfigProviderProps, HightideProvider, type HightideTranslationEntries, type HightideTranslationLocales, IconButton, IconButtonBase, type IconButtonBaseProps, type IconButtonProps, type IdentifierFilterValue, InfiniteScroll, type InfiniteScrollProps, Input, InputDialog, type InputModalProps, type InputProps, InsideLabelInput, LabelledCheckbox, type LabelledCheckboxProps, LanguageDialog, LanguageSelect, type LinkComponentProps, type ListNavigationOptions, type ListNavigationReturn, LoadingAndErrorComponent, type LoadingAndErrorComponentProps, LoadingAnimation, type LoadingAnimationProps, type LoadingComponentProps, LoadingContainer, LocaleContext, type LocaleContextValue, LocaleProvider, type LocaleProviderProps, type LocalizationConfig, LocalizationUtil, LoopingArrayCalculator, type LoopingRangeBound, type LoopingRangeResult, MarkdownInterpreter, type MarkdownInterpreterProps, MathUtil, Menu, type MenuBag, MenuItem, type MenuItemProps, type MenuProps, type Month, MultiSearchWithMapping, MultiSelect, MultiSelectButton, type MultiSelectButtonProps, MultiSelectChipDisplay, MultiSelectChipDisplayButton, type MultiSelectChipDisplayButtonProps, type MultiSelectChipDisplayProps, MultiSelectContent, type MultiSelectContentProps, MultiSelectContext, type MultiSelectContextActions, type MultiSelectContextComputedState, type MultiSelectContextConfig, type MultiSelectContextIds, type MultiSelectContextLayout, type MultiSelectContextSearch, type MultiSelectContextState, type MultiSelectContextType, type MultiSelectIconAppearance, type MultiSelectIds, MultiSelectOption, MultiSelectOptionDisplayContext, type MultiSelectOptionDisplayLocation, type MultiSelectOptionProps, type MultiSelectOptionType, MultiSelectProperty, type MultiSelectPropertyProps, type MultiSelectProps, MultiSelectRoot, type MultiSelectRootProps, MultiSubjectSearchWithMapping, NO_COLUMN_ID, Navigation, NavigationCard, type NavigationCardLinkProps, type NavigationCardProps, type NavigationContextActions, type NavigationContextType, type NavigationItemData, NavigationItemList, type NavigationItemListProps, type NavigationItemState, type NavigationItemType, type NavigationLinkComponentProps, type NavigationProps, NavigationProvider, type NavigationProviderProps, NumberFilterPopUp, NumberInput, type NumberInputProps, NumberProperty, type NumberPropertyProps, NumberStepperInput, type NumberStepperInputLayout, type NumberStepperInputProps, type OverlayItem, OverlayRegistry, Pagination, type PaginationProps, PopUp, PopUpContext, type PopUpContextType, PopUpOpener, type PopUpOpenerBag, type PopUpOpenerProps, type PopUpProps, PopUpRoot, type PopUpRootProps, Portal, type PortalProps, type ProcessModelActivityIconKind, ProcessModelActivityNode, type ProcessModelActivityNodeKind, type ProcessModelActivityNodeProps, ProcessModelCanvas, type ProcessModelCanvasProps, type ProcessModelEdge, type ProcessModelEdgePointResult, type ProcessModelEdgeStrokeStyle, type ProcessModelGraph, type ProcessModelGraphActivityNode, type ProcessModelGraphNode, type ProcessModelGraphTerminalNode, type ProcessModelGraphWithTraces, type ProcessModelLayoutResult, ProcessModelLayoutUtilities, type ProcessModelLibraryEntry, type ProcessModelNodeBase, type ProcessModelNodePosition, type ProcessModelTerminalKind, ProcessModelTerminalNode, type ProcessModelTerminalNodeProps, type ProcessModelTrace, ProcessModelTraceReplay, type ProcessModelTraceReplayProps, ProgressIndicator, type ProgressIndicatorProps, PromiseUtils, PropertyBase, type PropertyBaseProps, type PropertyField, PropsUtil, type PropsWithBagFunction, type PropsWithBagFunctionOrChildren, type Range, type RangeOptions, ReactRefsUtil, type ResolvedTheme, type ScrollMetrics, ScrollPicker, type ScrollPickerProps, ScrollableList, type ScrollableListProps, type ScrollbarState, SearchBar, type SearchBarProps, type SegmentBounds, type SegmentBuffer, type SegmentEditState, type SegmentLayoutOptions, type SegmentValues, Select, SelectButton, type SelectButtonProps, SelectContent, type SelectContentProps, SelectContext, type SelectContextActions, type SelectContextComputedState, type SelectContextConfig, type SelectContextIds, type SelectContextLayout, type SelectContextSearch, type SelectContextState, type SelectContextType, type SelectIconAppearance, type SelectIds, SelectOption, SelectOptionDisplayContext, type SelectOptionDisplayLocation, type SelectOptionProps, type SelectOptionType, type SelectProps, SelectRoot, type SelectRootProps, type SelectionOption, SimpleSearch, SimpleSearchWithMapping, type SingleOrArray, SingleSelectProperty, type SingleSelectPropertyProps, type SingleSelectionReturn, SortingList, type SortingListItem, type SortingListProps, StepperBar, type StepperBarProps, type StepperLoopEvent, type StepperState, StorageListener, type StorageSubscriber, type SuperSet, type SwipeDirection, type SwipeEventData, type SwipeInputMode, type SwipeStartRegion, Switch, type SwitchProps, type TabContextType, type TabInfo, TabList, TabPanel, TabSwitcher, type TabSwitcherProps, TabView, Table, TableBody, TableCell, type TableCellProps, TableColumn, TableColumnDefinitionContext, type TableColumnDefinitionContextType, type TableColumnProps, TableColumnSwitcher, TableColumnSwitcherPopUp, type TableColumnSwitcherPopUpProps, type TableColumnSwitcherProps, TableContainerContext, type TableContainerContextType, TableDisplay, type TableDisplayProps, TableFilter, TableFilterButton, type TableFilterButtonProps, TableHeader, type TableHeaderProps, TablePageSizeSelect, type TablePageSizeSelectProps, TablePagination, TablePaginationMenu, type TablePaginationMenuProps, type TablePaginationProps, type TableProps, TableProvider, type TableProviderProps, TableSortButton, type TableSortButtonProps, TableStateContext, type TableStateContextType, TableStateWithoutSizingContext, type TableStateWithoutSizingContextType, type TableVirtualizationOptions, TableWithSelection, type TableWithSelectionProps, TableWithSelectionProvider, type TableWithSelectionProviderProps, TagsFilterPopUp, type TagsFilterPopUpProps, TagsSingleFilterPopUp, type TagsSingleFilterPopUpProps, TextFilterPopUp, TextImage, type TextImageProps, TextProperty, type TextPropertyProps, Textarea, type TextareaProps, TextareaWithHeadline, type TextareaWithHeadlineProps, type ThemeConfig, ThemeContext, ThemeDialog, type ThemeDialogProps, ThemeIcon, type ThemeIconProps, ThemeProvider, type ThemeProviderProps, ThemeSelect, type ThemeSelectProps, type ThemeType, ThemeUtil, TimeDisplay, TimeInput, type TimeInputProps, TimePicker, type TimePickerMillisecondIncrement, type TimePickerMinuteIncrement, type TimePickerProps, type TimePickerSecondIncrement, ToggleableInput, Tooltip, type TooltipConfig, TooltipContext, type TooltipContextType, TooltipDisplay, type TooltipDisplayProps, type TooltipProps, TooltipRoot, type TooltipRootProps, TooltipTrigger, type TooltipTriggerBag, type TooltipTriggerContextValue, type TooltipTriggerProps, Transition, type TransitionState, type TransitionWrapperProps, type TreeExpansionActionOptions, type TreeExpansionOptions, type TreeExpansionReturn, type TreeFocusNavigationOptions, type TreeFocusNavigationReturn, type TreeIndex, type TreeIndexEntry, type TreeItem, type TreeNavigationActionOptions, type TreeNavigationOptions, type TreeNavigationReturn, type TreeNode, TreeUtilities, type UnBoundedRange, type UseAnchoredPositionOptions, type UseAnchoredPostitionProps, type UseChangingNumberOptions, type UseComboboxActions, type UseComboboxComputedState, type UseComboboxOption, type UseComboboxOptions, type UseComboboxReturn, type UseComboboxState, type UseCreateFormProps, type UseCreateFormResult, type UseDelayOptions, type UseDelayOptionsResolved, type UseFocusTrapProps, type UseFormFieldOptions, type UseFormFieldParameter, type UseFormObserverKeyProps, type UseFormObserverProps, type UseMultiSelectActions, type UseMultiSelectComputedState, type UseMultiSelectFirstHighlightBehavior, type UseMultiSelectOption, type UseMultiSelectOptions, type UseMultiSelectReturn, type UseMultiSelectState, type UseMultiSelectionOption, type UseMultiSelectionOptions, type UseMultiSelectionReturn, type UseNaturalColumnWidthLockOptions, type UseOutsideClickHandlers, type UseOutsideClickOptions, type UseOutsideClickProps, type UseOverlayRegistryProps, type UseOverlayRegistryResult, type UsePresenceRefProps, type UseResizeObserverProps, type UseScrollbarStateProps, type UseSearchOptions, type UseSearchReturn, type UseSelectActions, type UseSelectComputedState, type UseSelectFirstHighlightBehavior, type UseSelectOption, type UseSelectOptions, type UseSelectReturn, type UseSelectState, type UseSingleSelectionOptions, type UseTypeAheadSearchOptions, type UseTypeAheadSearchReturn, type UseUpdatingDateStringProps, UseValidators, type UseVirtualizedRowsOptions, type UseVirtualizedRowsResult, type UserFormFieldProps, type ValidatorError, type ValidatorResult, VerticalDivider, type VerticalDividerProps, VerticalNavigationMenuItem as VerticalNavigationItem, VerticalNavigationMenu, VerticalNavigationMenuItem, type VerticalNavigationMenuItemProps, type VerticalNavigationMenuProps, NavigationProvider as VerticalNavigationProvider, type VirtualizationScroll, VirtualizedCardGrid, type VirtualizedCardGridProps, VirtualizedTableBody, type VirtualizedTableBodyProps, Visibility, type VisibilityProps, type WeekDay, YearMonthPicker, type YearMonthPickerProps, buildSegmentLayout, builder, chunkIntoRows, clearSegment, closestMatch, columnsForWidth, composeDate, createLoopingList, createLoopingListWithIndex, createNoColumnPlaceholderColumn, decomposeDate, editableSegmentTypes, editableTypesOf, equalSizeGroups, findPageScrollContainer, findScrollableAncestor, formatSegment, getNeighbours, getProcessModelLibraryEntry, getScrollMetrics, hasNonExcludedColumns, hightideTranslation, hightideTranslationLocales, isComplete, isEmpty, isNearBottom, match, mergeProps, noop, overscanRowsForBuffer, processModelLibrary, range, resolveSetState, resolveTreeNodePath, segmentBounds, segmentPlaceholder, setDayPeriod, stepSegment, timeUnitTranslationKey, toSizeVars, toTreeNodes, typeDigit, useAnchoredPosition, useChangingNumber, useCombobox, useComboboxContext, useControlledState, useCreateForm, useDateTimeFormat, useDebouncer, useDelay, useDialogContext, useDrawerContext, useEventCallbackStabilizer, useFilterValueTranslation, useFocusGuards, useFocusManagement, useFocusOnceVisible, useFocusTrap, useForm, useFormField, useFormObserver, useFormObserverKey, useHandleRefs, useHightideConfig, useHightideTranslation, useICUTranslation, useIsMounted, useLanguage, useListNavigation, useLocale, useLogOnce, useLogUnstableDependencies, useMultiSelect, useMultiSelectContext, useMultiSelectOptionDisplayLocation, useMultiSelection, useNaturalColumnWidthLock, useNavigationContext, useNavigationItem, useOutsideClick, useOverlayRegistry, useOverwritableState, usePopUpContext, usePresenceRef, useRerender, useResizeObserver, useScrollObserver, useScrollbarState, useSearch, useSelect, useSelectContext, useSelectOptionDisplayLocation, useSingleSelection, useStepperHold, useStorage, useSwipeGesture, useTabContext, useTableColumnDefinitionContext, useTableContainerContext, useTableStateContext, useTableStateWithoutSizingContext, useTheme, useThrottle, useTimeZone, useTooltip, useTransitionState, useTranslatedValidators, useTreeExpansion, useTreeFocusNavigation, useTreeNavigation, useTypeAheadSearch, useUpdatingDateString, useNavigationContext as useVerticalNavigationContext, useNavigationItem as useVerticalNavigationItem, useVirtualizedRows, useWindowResizeObserver, validateEmail, writeToClipboard };