@shlinkio/shlink-frontend-kit 0.9.13 → 1.0.1

package/dist/index.d.ts

@@ -1,14 +1,25 @@
-import { CardProps } from 'reactstrap';
 import { ChangeEvent } from 'react';
+import { Coords } from '@floating-ui/utils';
 import { Dispatch } from 'react';
-import { DropdownToggleProps } from 'reactstrap/types/lib/DropdownToggle';
 import { FC } from 'react';
+import { ForwardedRef } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { HTMLProps } from 'react';
+import { InputHTMLAttributes } from 'react';
 import { JSX } from 'react/jsx-runtime';
+import { LinkProps } from 'react-router';
+import { Placement } from '@floating-ui/react';
+import { Property } from 'csstype';
 import { PropsWithChildren } from 'react';
 import { ReactNode } from 'react';
+import { RefAttributes } from 'react';
+import { ReferenceType } from '@floating-ui/react-dom';
+import { ReferenceType as ReferenceType_2 } from '@floating-ui/react';
 import { RefObject } from 'react';
 import { SetStateAction } from 'react';
 
+declare type AnchorProps = Omit<LinkProps, 'role' | 'aria-disabled' | 'tabIndex' | 'type'>;
+
 export declare type ArrowKeyNavigationOptions = {
     /** Query selector for focusable elements that need to be included in the loop */
     elementsSelector: string;
@@ -20,47 +31,205 @@ export declare type ArrowKeyNavigationOptions = {
     horizontal?: boolean;
 };
 
-declare type BooleanControlProps = PropsWithChildren<{
-    checked?: boolean;
+export declare type BaseInputProps = {
+    size?: Size;
+    feedback?: 'error';
+    /**
+     * Whether the input should have an opinionated style or not. Defaults to 'default'.
+     * An unstyled input can be useful to wrap or customize.
+     */
+    variant?: 'default' | 'unstyled';
+};
+
+declare type BaseInputProps_2 = Omit<SearchInputProps, 'role' | 'aria-autocomplete' | 'aria-expanded' | 'aria-controls' | 'aria-activedescendant' | 'onChange' | 'autoComplete' | 'autoCorrect'>;
+
+export declare const BaseNavBar: FC<NavBarProps>;
+
+declare type BooleanControlProps = Omit<HTMLProps<HTMLInputElement>, 'type' | 'onChange' | 'value' | 'defaultValue'> & {
     onChange?: (checked: boolean, e: ChangeEvent<HTMLInputElement>) => void;
+};
+
+export declare const BRAND_COLOR_ALPHA_DM = "rgba(70, 150, 229, 0.4)";
+
+export declare const BRAND_COLOR_ALPHA_LM = "rgba(32, 120, 207, 0.4)";
+
+export declare const BRAND_COLOR_DM = "#4696e5";
+
+export declare const BRAND_COLOR_LM = "#2078CF";
+
+export declare const brandColor: () => "#4696e5" | "#2078CF";
+
+export declare const brandColorAlpha: () => "rgba(70, 150, 229, 0.4)" | "rgba(32, 120, 207, 0.4)";
+
+export declare const Button: ForwardRefExoticComponent<(({
+disabled?: boolean;
+className?: string;
+variant?: "primary" | "secondary" | "danger";
+type?: HTMLButtonElement["type"];
+size?: Size;
+inline?: boolean;
+solid?: boolean;
+} & LinkProps & {
+children?: ReactNode | undefined;
+}) | Omit<{
+disabled?: boolean;
+className?: string;
+variant?: "primary" | "secondary" | "danger";
+type?: HTMLButtonElement["type"];
+size?: Size;
+inline?: boolean;
+solid?: boolean;
+} & RegularButtonProps & {
+children?: ReactNode | undefined;
+}, "ref">) & RefAttributes<HTMLButtonElement | HTMLAnchorElement>>;
+
+export declare type ButtonProps = PropsWithChildren<{
+    disabled?: boolean;
     className?: string;
+    variant?: 'primary' | 'secondary' | 'danger';
+    type?: HTMLButtonElement['type'];
+    size?: Size;
     inline?: boolean;
-}>;
+    solid?: boolean;
+} & (RegularButtonProps | LinkButtonProps_2)>;
+
+declare type ButtonProps_2 = Omit<HTMLProps<HTMLButtonElement>, 'role' | 'disabled' | 'aria-disabled' | 'tabIndex' | 'type'>;
 
 export declare type Callback = () => unknown;
 
-export declare const changeThemeInMarkup: (theme: Theme) => void | undefined;
+export declare const Card: ForwardRefExoticComponent<CardProps & RefAttributes<HTMLDivElement>> & {
+    Body: ForwardRefExoticComponent<CardProps & RefAttributes<HTMLDivElement>>;
+    Header: ForwardRefExoticComponent<CardProps & RefAttributes<HTMLDivElement>>;
+    Footer: ForwardRefExoticComponent<CardProps & RefAttributes<HTMLDivElement>>;
+};
 
-/** @deprecated */
-export declare const Checkbox: FC<BooleanControlProps>;
+/**
+ * A ModalDialog that renders a Card as its content
+ */
+export declare const CardModal: FC<CardModalProps>;
 
-export declare function determineOrder<Fields extends string = string>(orderDirChange: OrderDirChange<Fields>): Order<Fields>;
+export declare type CardModalProps = Omit<ModalDialogProps, 'title' | 'size'> & (CoverCardModalProps | RegularCardModalProps);
 
-/** @deprecated */
-export declare function determineOrder<Fields extends string = string>(currentField?: Fields, newField?: Fields, currentOrderDir?: OrderDir): Order<Fields>;
+export declare type CardProps = Omit<HTMLProps<HTMLDivElement>, 'ref'>;
 
-export declare function determineOrderDir<Fields extends string = string>(orderDirChange: OrderDirChange<Fields>): OrderDir;
+export declare type CellProps = HTMLProps<HTMLTableCellElement> & {
+    /**
+     * The name of the column to be displayed in small resolutions when the table is responsive, where the cells collapse.
+     * It is ignored for non-responsive tables.
+     */
+    columnName?: string;
+    /**
+     * Whether to use a th or td tag. If not provided, it is inferred based on the section, using td when inside tbody,
+     * and th when inside thead or tfoot
+     */
+    type?: 'td' | 'th';
+};
 
-/** @deprecated */
-export declare function determineOrderDir<Fields extends string = string>(currentField?: Fields, newField?: Fields, currentOrderDir?: OrderDir): OrderDir;
+export declare const changeThemeInMarkup: (theme: Theme) => void | undefined;
+
+export declare const Checkbox: ForwardRefExoticComponent<Omit<BooleanControlProps, "ref"> & RefAttributes<HTMLInputElement>>;
+
+export declare type CheckboxProps = BooleanControlProps;
 
-/** @deprecated */
-export declare const DropdownBtn: FC<DropdownBtnProps>;
+export declare const CloseButton: ForwardRefExoticComponent<CloseButtonProps & RefAttributes<HTMLButtonElement>>;
 
-export declare type DropdownBtnMenuProps = PropsWithChildren<{
-    minWidth?: number;
-    /** Accessible label for screen readers. Defaults to "Options" */
+export declare type CloseButtonProps = {
     label?: string;
+    onClick?: HTMLProps<HTMLButtonElement>['onClick'];
+    className?: string;
+    size?: Size;
+    solid?: boolean;
+};
+
+declare type CommonCardModalProps = {
+    /** Modal header title */
+    title: RequiredReactNode;
+};
+
+export declare const CopyToClipboardButton: FC<CopyToClipboardButtonProps>;
+
+export declare type CopyToClipboardButtonProps = Omit<HTMLProps<HTMLButtonElement>, 'type' | 'onClick' | 'size'> & {
+    /** Text to be copied when the button is clicked */
+    text: string;
+    /** Size of the button. Defaults to `lg` */
+    size?: Size;
+    /** Test seam */
+    initialCopied?: boolean;
+    /** Test seam */
+    navigator_?: typeof globalThis.navigator;
+};
+
+declare type CoverCardModalProps = CommonCardModalProps & {
+    /**
+     * Cover dialogs have a body that span the whole dialog, and no buttons.
+     * The header overlaps the body with semi-transparent background.
+     */
+    variant: 'cover';
+};
+
+export declare const Details: FC<DetailsProps>;
+
+export declare type DetailsProps = Omit<HTMLProps<HTMLDetailsElement>, 'ref'> & {
+    summary: ReactNode;
+    summaryClasses?: string;
+};
+
+/**
+ * Generate an Order object for the new order field, based on previous order field and direction.
+ */
+export declare function determineOrder<Fields extends string = string>(orderDirChange: OrderDirChange<Fields>): Order<Fields>;
+
+/**
+ * Generate an Order dir for the new order field, based on previous order field and direction.
+ */
+export declare function determineOrderDir<Fields extends string = string>(orderDirChange: OrderDirChange<Fields>): OrderDir;
+
+export declare const Dropdown: FC<DropdownProps> & {
+    Item: FC<MenuItemProps>;
+    Separator: FC;
+    Title: FC<{
+        children?: ReactNode | undefined;
+    }>;
+    Misc: FC<HTMLProps<HTMLDivElement>>;
+};
+
+export declare type DropdownProps = PropsWithChildren<{
+    buttonContent: RequiredReactNode;
+    buttonSize?: Size;
+    buttonClassName?: string;
+    buttonVariant?: 'button' | 'link' | 'text';
+    buttonDisabled?: boolean;
+    /** Set as the button's `aria-label` attribute */
+    buttonLabel?: string;
+    /** Classes to be set on the containing wrapper element */
+    containerClassName?: string;
+    /** Classes to be set on the menu element */
+    menuClassName?: string;
+    /**
+     * Whether the menu should align with the right or the left side of the toggle button in case it is bigger.
+     * Defaults to 'left'.
+     */
+    menuAlignment?: 'left' | 'right';
+    /** Distance between toggle button and menu when open, in pixels. Defaults to 3 */
+    menuOffset?: number;
+    /** Whether to hide the caret or not. Defaults to false */
+    caretless?: boolean;
 }>;
 
-export declare type DropdownBtnProps = PropsWithChildren<Omit<DropdownToggleProps, 'caret' | 'size' | 'outline'> & {
-    text: ReactNode;
-    noCaret?: boolean;
-    className?: string;
-    dropdownClassName?: string;
-    inline?: boolean;
-    minWidth?: number;
-    size?: 'sm' | 'md' | 'lg';
+export declare const ELLIPSIS = "...";
+
+declare type Ellipsis = typeof ELLIPSIS;
+
+export declare type ExitAction = 'confirm' | 'cancel';
+
+export declare const formatNumber: (number: number | string) => string;
+
+declare type FormControlWithFeedbackProps = PropsWithChildren<{
+    /** An error message to display under the input. Will cause the input to be set with `error` feedback. */
+    error?: ReactNode;
+    /** Informative help to be display under the input */
+    helpText?: ReactNode;
+    'data-testid'?: string;
 }>;
 
 export declare const getSystemPreferredTheme: (_matchMedia?: ((query: string) => MediaQueryList) & typeof matchMedia) => Theme;
@@ -69,18 +238,13 @@ export declare const HIGHLIGHTED_COLOR = "#f77f28";
 
 export declare const HIGHLIGHTED_COLOR_ALPHA = "rgba(247, 127, 40, 0.4)";
 
-/** @deprecated */
-export declare const InputFormGroup: FC<InputFormGroupProps>;
+export declare const Input: ForwardRefExoticComponent<Omit<InputHTMLAttributes<HTMLInputElement>, "checked" | "size" | "defaultChecked"> & BaseInputProps & {
+borderless?: boolean;
+} & RefAttributes<HTMLInputElement>>;
 
-export declare type InputFormGroupProps = PropsWithChildren<{
-    value: string;
-    onChange: (newValue: string) => void;
-    type?: HTMLInputElement['type'];
-    required?: boolean;
-    placeholder?: string;
-    className?: string;
-    labelClassName?: string;
-}>;
+export declare type InputProps = Omit<InputHTMLAttributes<HTMLInputElement>, 'size' | 'checked' | 'defaultChecked'> & BaseInputProps & {
+    borderless?: boolean;
+};
 
 export declare const isDarkThemeEnabled: () => boolean;
 
@@ -94,49 +258,178 @@ export declare const isDarkThemeEnabled: () => boolean;
  */
 export declare function isLightColor(colorHex: string): boolean;
 
-/** @deprecated */
-export declare const LabeledFormGroup: FC<LabeledFormGroupProps>;
+declare type ItemProps = {
+    active?: boolean;
+};
 
-declare type LabeledFormGroupProps = PropsWithChildren<{
-    label: ReactNode;
-    noMargin?: boolean;
-    className?: string;
-    labelClassName?: string;
-    id?: string;
-}>;
+export declare const keyForPage: (pageNumber: NumberOrEllipsis, index: number) => string;
+
+export declare const Label: FC<LabelProps>;
+
+export declare const LabelledInput: ForwardRefExoticComponent<Omit<InputProps, "className" | "id" | "feedback"> & {
+error?: ReactNode;
+helpText?: ReactNode;
+'data-testid'?: string;
+} & {
+children?: ReactNode | undefined;
+} & {
+label: RequiredReactNode;
+inputClassName?: string;
+/** Alternative to `required`. Causes the input to be required, without displaying an asterisk */
+hiddenRequired?: boolean;
+} & RefAttributes<HTMLInputElement>>;
+
+export declare type LabelledInputProps = Omit<InputProps, 'className' | 'id' | 'feedback'> & FormControlWithFeedbackProps & {
+    label: RequiredReactNode;
+    inputClassName?: string;
+    /** Alternative to `required`. Causes the input to be required, without displaying an asterisk */
+    hiddenRequired?: boolean;
+};
 
-export declare const MAIN_COLOR = "#4696e5";
+export declare const LabelledRevealablePasswordInput: ForwardRefExoticComponent<Omit<RevealablePasswordInputProps, "className" | "id" | "feedback"> & {
+error?: ReactNode;
+helpText?: ReactNode;
+'data-testid'?: string;
+} & {
+children?: ReactNode | undefined;
+} & {
+label: RequiredReactNode;
+inputClassName?: string;
+/** Alternative to `required`. Causes the input to be required, without displaying an asterisk */
+hiddenRequired?: boolean;
+} & RefAttributes<HTMLInputElement>>;
+
+export declare type LabelledRevealablePasswordInputProps = Omit<RevealablePasswordInputProps, 'className' | 'id' | 'feedback'> & FormControlWithFeedbackProps & {
+    label: RequiredReactNode;
+    inputClassName?: string;
+    /** Alternative to `required`. Causes the input to be required, without displaying an asterisk */
+    hiddenRequired?: boolean;
+};
+
+export declare const LabelledSelect: ForwardRefExoticComponent<Omit<LabelledSelectProps, "ref"> & RefAttributes<HTMLSelectElement>>;
+
+export declare type LabelledSelectProps = Omit<SelectProps, 'className' | 'id'> & FormControlWithFeedbackProps & {
+    label: RequiredReactNode;
+    selectClassName?: string;
+    /** Alternative to `required`. Causes the input to be required, without displaying an asterisk */
+    hiddenRequired?: boolean;
+};
+
+export declare type LabelProps = HTMLProps<HTMLLabelElement> & {
+    required?: boolean;
+};
+
+export declare const LinkButton: ForwardRefExoticComponent<Omit<LinkButtonProps, "ref"> & RefAttributes<HTMLButtonElement>>;
+
+export declare type LinkButtonProps = Omit<HTMLProps<HTMLButtonElement>, 'size' | 'type'> & {
+    size?: Size;
+    type?: HTMLButtonElement['type'];
+};
+
+declare type LinkButtonProps_2 = LinkProps;
+
+export declare function Listbox<Item>({ id, items, onSelectItem, onActiveItemChange, renderItem, className, noItemsMessage, anchor, 'aria-label': label, ...rest }: ListboxProps<Item>): JSX.Element;
+
+export declare type ListboxProps<Item> = Omit<CardProps, 'id' | 'role' | 'aria-orientation'> & {
+    /** Map of items in the listbox, with a key representing them uniquely */
+    items: Map<string, Item>;
+    /** Invoked when the active item is selected via click or `Enter` */
+    onSelectItem: (item: Item) => void;
+    /** Invoked when the active item changes via vertical arrows or hover */
+    onActiveItemChange?: (key: string, item: Item) => void;
+    /** To customize the shape of an item */
+    renderItem: (item: Item) => ReactNode;
+    /** Used to link with the element controlling this listbox */
+    id: string;
+    /**
+     * Allows to optionally anchor this listbox to another element.
+     * If provided, it will attach arrow key and Enter press listeners to interact with the listbox.
+     */
+    anchor?: RefObject<HTMLElement | null>;
+    /**
+     * Message to display when the list of items is empty.
+     * Defaults to 'No items'.
+     */
+    noItemsMessage?: string;
+};
 
-export declare const MAIN_COLOR_ALPHA = "rgba(70, 150, 229, 0.4)";
+export declare const Menu: FC<MenuProps> & {
+    Item: FC<MenuItemProps>;
+    Separator: FC;
+    Title: FC<{
+        children?: ReactNode | undefined;
+    }>;
+    Misc: FC<HTMLProps<HTMLDivElement>>;
+};
 
-/** @deprecated */
+export declare type MenuItemProps = (ButtonProps_2 | AnchorProps) & {
+    selected?: boolean;
+    disabled?: boolean;
+};
+
+export declare type MenuProps = Omit<CardProps, 'role'> & {
+    /**
+     * Selector to determine elements that should be part of the focus sequence.
+     * Defaults to '[role="menuitem"]:not([disabled]):not([aria-disabled])'
+     */
+    focusableElementsSelector?: string;
+    /**
+     * Whether first focusable item should be focused or not.
+     * Defaults to false.
+     */
+    focusFirstItem?: boolean;
+    /**
+     * Optional callback invoked when a Menu.Item is clicked.
+     * If the Menu.Item has its own onClick, this callback will be called afterwards.
+     */
+    onItemClick?: () => void;
+};
+
+/**
+ * Component used to display a card with general information, about current page status, loading, etc.
+ */
 export declare const Message: FC<MessageProps>;
 
 export declare type MessageProps = PropsWithChildren<{
     className?: string;
     loading?: boolean;
-    fullWidth?: boolean;
-    type?: MessageType;
+    variant?: 'default' | 'error';
 }>;
 
-declare type MessageType = 'default' | 'error';
+export declare const ModalDialog: FC<ModalDialogProps>;
 
-/** @deprecated */
-export declare const NavPillItem: FC<NavPillItemProps>;
+export declare type ModalDialogProps = HTMLProps<HTMLDialogElement> & {
+    /** Whether the dialog is open or not */
+    open: boolean;
+    /** Invoked when the dialog is closed for any reason */
+    onClose: () => void;
+};
 
-declare type NavPillItemProps = PropsWithChildren<{
-    to: string;
-    replace?: boolean;
-}>;
+export declare const NavBar: FC<NavBarProps> & {
+    MenuItem: FC<LinkProps & ItemProps>;
+    Dropdown: FC<Omit<DropdownProps, "menuAlignment" | "buttonVariant" | "menuOffset"> & ItemProps>;
+};
+
+export declare type NavBarProps = HTMLProps<HTMLElement> & {
+    brand: RequiredReactNode;
+};
 
-/** @deprecated */
-export declare const NavPills: FC<NavPillsProps>;
+export declare const NavPills: FC<NavPillsProps> & {
+    Pill: FC<LinkProps>;
+};
 
-declare type NavPillsProps = PropsWithChildren<{
+export declare type NavPillsProps = PropsWithChildren<{
     fill?: boolean;
     className?: string;
 }>;
 
+declare type NoTitleProps = {
+    title?: never;
+    titleSize?: never;
+};
+
+export declare type NumberOrEllipsis = number | Ellipsis;
+
 export declare type Order<Fields> = {
     field?: Fields;
     dir?: OrderDir;
@@ -150,74 +443,184 @@ export declare type OrderDirChange<Fields extends string = string> = {
     currentOrderDir?: OrderDir;
 };
 
-/** @deprecated */
-export declare function OrderingDropdown<T extends string = string>({ items, order, onChange, isButton, right, prefixed }: OrderingDropdownProps<T>): JSX.Element;
+export declare function OrderingDropdown<T extends string = string>({ items, order, onChange, prefixed, buttonVariant, ...rest }: OrderingDropdownProps<T>): JSX.Element;
 
-export declare type OrderingDropdownProps<T extends string = string> = {
+export declare type OrderingDropdownProps<T extends string = string> = Omit<DropdownProps, 'buttonContent'> & {
     items: Record<T, string>;
     order: Order<T>;
-    onChange: (orderField?: T, orderDir?: OrderDir) => void;
-    isButton?: boolean;
-    right?: boolean;
+    onChange: (newOrder: Order<T>) => void;
     prefixed?: boolean;
 };
 
-export declare type OrderSetter<T> = {
-    (order: Order<T>): void;
-    /** @deprecated Pass the order object as the only argument */
-    (orderField?: T, orderDir?: OrderDir): void;
-};
-
 /**
  * Convert provided order object to string, with the pattern `${order.field}-${order.di}`.
  * @return - A `string` if the `dir` prop is set, `undefined` otherwise.
  */
 export declare const orderToString: <T>(order: Order<T>) => string | undefined;
 
+export declare const pageIsEllipsis: (pageNumber: NumberOrEllipsis) => pageNumber is Ellipsis;
+
+export declare const Paginator: FC<PaginatorProps>;
+
+export declare type PaginatorProps = {
+    pagesCount: number;
+    currentPage: number;
+} & ({
+    onPageChange: (currentPage: number) => void;
+} | {
+    urlForPage: (pageNumber: number) => string;
+});
+
 /**
  * Parses provided query string into an object.
  * Parameters ending with "[]" will be considered arrays and returned as a single prop with all values.
  */
 export declare const parseQueryString: <T>(search: string) => T;
 
+export declare type PillProps = LinkProps;
+
+export declare const prettifyPageNumber: (pageNumber: NumberOrEllipsis) => string;
+
 export declare const PRIMARY_DARK_COLOR = "#161b22";
 
 export declare const PRIMARY_LIGHT_COLOR = "white";
 
-/** @deprecated */
+export declare const progressivePagination: (currentPage: number, pageCount: number) => NumberOrEllipsis[];
+
+declare type RegularButtonProps = Omit<HTMLProps<HTMLButtonElement>, 'size' | 'type'>;
+
+declare type RegularCardModalProps = CommonCardModalProps & {
+    /** Danger dialogs use danger variants in title and confirm button */
+    variant?: 'default' | 'danger';
+    /** Determines the horizontal size of the dialog */
+    size?: Size | 'xl';
+    /** Value to display in confirm button. Defaults to 'Confirm' */
+    confirmText?: ReactNode;
+    /** Value to display in cancel button. Defaults to 'Cancel' */
+    cancelText?: ReactNode;
+    /** Whether the confirm button is disabled or not */
+    confirmDisabled?: boolean;
+    /**
+     * A footer with confirm and cancel buttons will be rendered if provided.
+     * Invoked when the confirm button is actioned.
+     */
+    onConfirm?: () => void;
+    /** Invoked after finishing the close transition */
+    onClosed?: (exitAction: ExitAction) => void;
+};
+
+export declare type RequiredReactNode = Exclude<ReactNode, undefined | null>;
+
+/**
+ * Component used to display the result of an operation, which can be a success, failure or warning.
+ */
 export declare const Result: FC<ResultProps>;
 
 export declare type ResultProps = PropsWithChildren<{
-    type: ResultType;
+    variant: 'success' | 'error' | 'warning';
     className?: string;
-    small?: boolean;
+    size?: Size;
 }>;
 
-export declare type ResultType = 'success' | 'error' | 'warning';
+export declare const RevealablePasswordInput: ForwardRefExoticComponent<Omit<InputProps, "type"> & {
+containerClassName?: string;
+} & RefAttributes<HTMLInputElement>>;
 
-/** @deprecated */
-export declare const RowDropdownBtn: FC<DropdownBtnMenuProps>;
+export declare type RevealablePasswordInputProps = Omit<InputProps, 'type'> & {
+    containerClassName?: string;
+};
 
-/** @deprecated */
-export declare const SearchField: ({ onChange, className, large, noBorder, initialValue, setTimeout_ }: SearchFieldProps) => JSX.Element;
+export declare const roundTen: (number: number) => number;
 
-declare type SearchFieldProps = {
-    onChange: (value: string) => void;
-    className?: string;
-    large?: boolean;
-    noBorder?: boolean;
-    initialValue?: string;
-    setTimeout_?: typeof setTimeout;
+export declare const RowDropdown: FC<RowDropdownProps> & {
+    Item: FC<MenuItemProps>;
+    Separator: FC;
+    Title: FC<{
+        children?: ReactNode | undefined;
+    }>;
+    Misc: FC<HTMLProps<HTMLDivElement>>;
 };
 
-/** @deprecated */
-export declare const SimpleCard: ({ title, children, bodyClassName, ...rest }: SimpleCardProps) => JSX.Element;
+export declare type RowDropdownProps = Omit<DropdownProps, 'caretless' | 'buttonContent' | 'buttonVariant'>;
 
-export declare type SimpleCardProps = Omit<CardProps, 'title'> & {
-    title?: ReactNode;
-    bodyClassName?: string;
+export declare const SearchCombobox: <T>(props: SearchComboboxProps<T> & {
+    ref?: ForwardedRef<HTMLInputElement>;
+}) => ReturnType<typeof SearchComboboxInner>;
+
+/**
+ * This component combines a SearchInput with a Listbox, to behave close to an editable combobox with autocomplete, as
+ * described in https://www.w3.org/WAI/ARIA/apg/patterns/combobox/examples/combobox-autocomplete-list/.
+ * The main difference is that the input is used only to search in the listbox, and once an item is selected, the input
+ * is cleared and the listbox is closed.
+ */
+declare function SearchComboboxInner<Item>({ searchResults, onSearch, onSelectSearchResult, renderSearchResult, size, // SearchInput defaults its size to 'lg'. Change it to 'md'
+    listboxSpan, onFocus, containerClassName, listboxClassName, ...rest }: SearchComboboxProps<Item>, ref: ForwardedRef<HTMLInputElement>): JSX.Element;
+
+export declare type SearchComboboxProps<Item> = BaseInputProps_2 & {
+    /** If defined, it will display a listbox with the search results */
+    searchResults?: Map<string, Item>;
+    /** Invoked when the search input value changes */
+    onSearch: (searchTerm: string) => void;
+    /** Invoked when the active search result is selected */
+    onSelectSearchResult: (item: Item) => void;
+    /** To customize the look and feel of a search result */
+    renderSearchResult: (item: Item) => ReactNode;
+    /**
+     * Determines how the listbox should span when visible.
+     * - `full`: Be always as big as the input, regardless its content.
+     * - `auto`: Take only the needed space to display its content, up to the width of the input.
+     *
+     * Defaults to `full`.
+     */
+    listboxSpan?: 'full' | 'auto';
+    /** Classes to add to the wrapping container */
+    containerClassName?: string;
+    /** Classes to add to the listbox */
+    listboxClassName?: string;
 };
 
+export declare const SearchInput: ForwardRefExoticComponent<Omit<InputProps, "value" | "className" | "onChange"> & {
+onChange: (searchTerm: string) => void;
+containerClassName?: string;
+inputClassName?: string;
+/** When set to true, it displays a loading indicator in place of the magnifyinf glass icon */
+loading?: boolean;
+/**
+* Whether onChange should be triggered immediately or debounced.
+* Defaults to false.
+*/
+immediate?: boolean;
+} & RefAttributes<HTMLInputElement>>;
+
+export declare type SearchInputProps = Omit<InputProps, 'className' | 'onChange' | 'value'> & {
+    onChange: (searchTerm: string) => void;
+    containerClassName?: string;
+    inputClassName?: string;
+    /** When set to true, it displays a loading indicator in place of the magnifyinf glass icon */
+    loading?: boolean;
+    /**
+     * Whether onChange should be triggered immediately or debounced.
+     * Defaults to false.
+     */
+    immediate?: boolean;
+};
+
+export declare type SectionType = 'head' | 'body' | 'footer';
+
+export declare const Select: ForwardRefExoticComponent<Omit<SelectProps, "ref"> & RefAttributes<HTMLSelectElement>>;
+
+declare type SelectElementProps = Omit<HTMLProps<HTMLSelectElement>, 'size' | 'checked' | 'defaultChecked'>;
+
+export declare type SelectProps = PropsWithChildren<SelectElementProps & BaseInputProps>;
+
+export declare const SimpleCard: ForwardRefExoticComponent<SimpleCardProps & RefAttributes<HTMLDivElement>>;
+
+export declare type SimpleCardProps = Omit<CardProps, 'title' | 'size'> & {
+    bodyClassName?: string;
+} & (TitleProps | NoTitleProps);
+
+export declare type Size = 'sm' | 'md' | 'lg';
+
 export declare const sortList: <List>(list: List[], { field, dir }: Order<keyof List>) => List[];
 
 /**
@@ -230,6 +633,61 @@ export declare const stringifyQueryParams: (params: Record<string, unknown | unk
 
 export declare const stringToOrder: <T>(order: string) => Order<T>;
 
+export declare const Table: FC<TableProps> & {
+    Row: FC<HTMLProps<HTMLTableRowElement>>;
+    Cell: FC<CellProps>;
+};
+
+export declare type TableElementProps = PropsWithChildren & {
+    className?: string;
+};
+
+export declare type TableProps = Omit<HTMLProps<HTMLTableElement>, 'size'> & {
+    header: ReactNode;
+    footer?: ReactNode;
+    /**
+     * By default, the table rows will collapse under large resolutions, and the headers will be hidden.
+     * Set `responsive={false}` to avoid this behavior.
+     */
+    responsive?: boolean;
+    /** Determines the padding in every cell. Defaults to md */
+    size?: Size;
+};
+
+export declare type TagItemProps = {
+    name: string;
+    color: string;
+};
+
+export declare const TagsAutocomplete: FC<TagsAutocompleteProps>;
+
+export declare type TagsAutocompleteProps = {
+    /** Full list of tags from which to build the suggestions */
+    tags: string[];
+    /** Tags currently selected */
+    selectedTags?: string[];
+    /** Invoked when tags are added or removed */
+    onTagsChange?: (tags: string[]) => void;
+    /** Invoked to determine what is the color of a tag */
+    getColorForTag?: (tag: string) => string;
+    /** Search input placeholder */
+    placeholder?: string;
+    /** Classes to be added to the wrapping container */
+    containerClassName?: string;
+    /**
+     * Whether to allow adding new arbitrary tags, or only select from the list of tags.
+     * Defaults to false.
+     */
+    immutable?: boolean;
+    /**
+     * How to filter the list of tags when searching:
+     *   - `startsWith`: those that start with the search term
+     *   -  `includes`: those that include the search term
+     * Defaults to `startsWith`.
+     */
+    searchMode?: 'startsWith' | 'includes';
+} & Pick<SearchComboboxProps<string>, 'placeholder' | 'size' | 'disabled' | 'aria-label'>;
+
 export declare type Theme = 'dark' | 'light';
 
 export declare type TimeoutToggle = typeof useTimeoutToggle;
@@ -247,20 +705,38 @@ export declare type TimeoutToggleOptions = {
     delay?: number;
 };
 
-export declare type ToggleResult = ToggleResultTuple | ToggleResultObject;
+declare type TitleProps = {
+    title: ReactNode;
+    titleSize?: Size;
+};
 
-export declare type ToggleResultObject = {
+export declare type ToggleResult = {
     flag: boolean;
     toggle: () => void;
     setToTrue: () => void;
     setToFalse: () => void;
 };
 
-/** @deprecated */
-export declare type ToggleResultTuple = [boolean, () => void, () => void, () => void];
+export declare const ToggleSwitch: ForwardRefExoticComponent<Omit<BooleanControlProps, "ref"> & RefAttributes<HTMLInputElement>>;
 
-/** @deprecated */
-export declare const ToggleSwitch: FC<BooleanControlProps>;
+export declare type ToggleSwitchProps = BooleanControlProps;
+
+/**
+ * Renders a tooltip component with the content returned by useTooltip()
+ *
+ * ```
+ * const { anchor, tooltip } = useTooltip('bottom');
+ * return (
+ *   <>
+ *     <button {...anchor}>Hover me</button>
+ *     <Tooltip {...tooltip}>This is a tooltip</Tooltip>
+ *   </>
+ * )
+ * ```
+ */
+export declare const Tooltip: FC<TooltipProps>;
+
+export declare type TooltipProps = PropsWithChildren<ReturnType<typeof useTooltip>['tooltip']>;
 
 /**
  * Allows focus navigation via arrow keys on the elements of a container.
@@ -270,13 +746,8 @@ export declare const ToggleSwitch: FC<BooleanControlProps>;
  */
 export declare function useArrowKeyNavigation(containerRef: RefObject<HTMLElement | null>, { elementsSelector, focusFirstItem, vertical, horizontal }: ArrowKeyNavigationOptions): void;
 
-/** @deprecated Use `useRef<T>(null) instead */
-export declare const useElementRef: <T extends HTMLElement>() => RefObject<T | null>;
-
 export declare const useGoBack: () => () => void | Promise<void>;
 
-export declare const useOrder: <T>(initialOrder: Order<T>) => [Order<T>, OrderSetter<T>];
-
 export declare const useParsedQuery: <T>() => T;
 
 export declare const useTheme: (initialTheme?: Theme) => readonly [Theme, Dispatch<SetStateAction<Theme>>];
@@ -297,18 +768,841 @@ export declare type UseTimeoutResult = {
     clearCurrentTimeout: () => void;
 };
 
-/**
- * Passing individual args is deprecated. Pass an object of options instead.
- */
-export declare const useTimeoutToggle: (initialValueOrOptions?: TimeoutToggleOptions | boolean, secondArg?: number, setTimeout_?: typeof setTimeout, clearTimeout_?: typeof clearTimeout) => [boolean, () => void];
+export declare const useTimeoutToggle: ({ initialValue, delay }?: TimeoutToggleOptions, setTimeout_?: typeof setTimeout, clearTimeout_?: typeof clearTimeout) => [boolean, () => void];
 
-/** @deprecated Returning result as tuple is deprecated */
-export declare function useToggle(initialValue?: boolean, asObject?: false): ToggleResultTuple;
+export declare function useToggle(initialValue?: boolean): ToggleResult;
 
 /**
- * @param asObject - Whether the result should be returned as an object or as a tuple.
- *                   Deprecated. Future releases will always return an object.
+ * Initializes the properties required to render a tooltip anchored to another element.
  */
-export declare function useToggle(initialValue: boolean, asObject: true): ToggleResultObject;
+export declare const useTooltip: ({ placement }?: UseTooltipOptions) => {
+    anchor: {
+        ref: ((node: ReferenceType | null) => void) & ((node: ReferenceType_2 | null) => void);
+    };
+    tooltip: {
+        refSetter: ((node: HTMLElement | null) => void) & ((node: HTMLElement | null) => void);
+        isMounted: boolean;
+        styles: {
+            accentColor?: Property.AccentColor | undefined;
+            alignContent?: Property.AlignContent | undefined;
+            alignItems?: Property.AlignItems | undefined;
+            alignSelf?: Property.AlignSelf | undefined;
+            alignTracks?: Property.AlignTracks | undefined;
+            animationComposition?: Property.AnimationComposition | undefined;
+            animationDelay?: Property.AnimationDelay<string & {}> | undefined;
+            animationDirection?: Property.AnimationDirection | undefined;
+            animationDuration?: Property.AnimationDuration<string & {}> | undefined;
+            animationFillMode?: Property.AnimationFillMode | undefined;
+            animationIterationCount?: Property.AnimationIterationCount | undefined;
+            animationName?: Property.AnimationName | undefined;
+            animationPlayState?: Property.AnimationPlayState | undefined;
+            animationTimeline?: Property.AnimationTimeline | undefined;
+            animationTimingFunction?: Property.AnimationTimingFunction | undefined;
+            appearance?: Property.Appearance | undefined;
+            aspectRatio?: Property.AspectRatio | undefined;
+            backdropFilter?: Property.BackdropFilter | undefined;
+            backfaceVisibility?: Property.BackfaceVisibility | undefined;
+            backgroundAttachment?: Property.BackgroundAttachment | undefined;
+            backgroundBlendMode?: Property.BackgroundBlendMode | undefined;
+            backgroundClip?: Property.BackgroundClip | undefined;
+            backgroundColor?: Property.BackgroundColor | undefined;
+            backgroundImage?: Property.BackgroundImage | undefined;
+            backgroundOrigin?: Property.BackgroundOrigin | undefined;
+            backgroundPositionX?: Property.BackgroundPositionX<string | number> | undefined;
+            backgroundPositionY?: Property.BackgroundPositionY<string | number> | undefined;
+            backgroundRepeat?: Property.BackgroundRepeat | undefined;
+            backgroundSize?: Property.BackgroundSize<string | number> | undefined;
+            blockOverflow?: Property.BlockOverflow | undefined;
+            blockSize?: Property.BlockSize<string | number> | undefined;
+            borderBlockColor?: Property.BorderBlockColor | undefined;
+            borderBlockEndColor?: Property.BorderBlockEndColor | undefined;
+            borderBlockEndStyle?: Property.BorderBlockEndStyle | undefined;
+            borderBlockEndWidth?: Property.BorderBlockEndWidth<string | number> | undefined;
+            borderBlockStartColor?: Property.BorderBlockStartColor | undefined;
+            borderBlockStartStyle?: Property.BorderBlockStartStyle | undefined;
+            borderBlockStartWidth?: Property.BorderBlockStartWidth<string | number> | undefined;
+            borderBlockStyle?: Property.BorderBlockStyle | undefined;
+            borderBlockWidth?: Property.BorderBlockWidth<string | number> | undefined;
+            borderBottomColor?: Property.BorderBottomColor | undefined;
+            borderBottomLeftRadius?: Property.BorderBottomLeftRadius<string | number> | undefined;
+            borderBottomRightRadius?: Property.BorderBottomRightRadius<string | number> | undefined;
+            borderBottomStyle?: Property.BorderBottomStyle | undefined;
+            borderBottomWidth?: Property.BorderBottomWidth<string | number> | undefined;
+            borderCollapse?: Property.BorderCollapse | undefined;
+            borderEndEndRadius?: Property.BorderEndEndRadius<string | number> | undefined;
+            borderEndStartRadius?: Property.BorderEndStartRadius<string | number> | undefined;
+            borderImageOutset?: Property.BorderImageOutset<string | number> | undefined;
+            borderImageRepeat?: Property.BorderImageRepeat | undefined;
+            borderImageSlice?: Property.BorderImageSlice | undefined;
+            borderImageSource?: Property.BorderImageSource | undefined;
+            borderImageWidth?: Property.BorderImageWidth<string | number> | undefined;
+            borderInlineColor?: Property.BorderInlineColor | undefined;
+            borderInlineEndColor?: Property.BorderInlineEndColor | undefined;
+            borderInlineEndStyle?: Property.BorderInlineEndStyle | undefined;
+            borderInlineEndWidth?: Property.BorderInlineEndWidth<string | number> | undefined;
+            borderInlineStartColor?: Property.BorderInlineStartColor | undefined;
+            borderInlineStartStyle?: Property.BorderInlineStartStyle | undefined;
+            borderInlineStartWidth?: Property.BorderInlineStartWidth<string | number> | undefined;
+            borderInlineStyle?: Property.BorderInlineStyle | undefined;
+            borderInlineWidth?: Property.BorderInlineWidth<string | number> | undefined;
+            borderLeftColor?: Property.BorderLeftColor | undefined;
+            borderLeftStyle?: Property.BorderLeftStyle | undefined;
+            borderLeftWidth?: Property.BorderLeftWidth<string | number> | undefined;
+            borderRightColor?: Property.BorderRightColor | undefined;
+            borderRightStyle?: Property.BorderRightStyle | undefined;
+            borderRightWidth?: Property.BorderRightWidth<string | number> | undefined;
+            borderSpacing?: Property.BorderSpacing<string | number> | undefined;
+            borderStartEndRadius?: Property.BorderStartEndRadius<string | number> | undefined;
+            borderStartStartRadius?: Property.BorderStartStartRadius<string | number> | undefined;
+            borderTopColor?: Property.BorderTopColor | undefined;
+            borderTopLeftRadius?: Property.BorderTopLeftRadius<string | number> | undefined;
+            borderTopRightRadius?: Property.BorderTopRightRadius<string | number> | undefined;
+            borderTopStyle?: Property.BorderTopStyle | undefined;
+            borderTopWidth?: Property.BorderTopWidth<string | number> | undefined;
+            bottom?: Property.Bottom<string | number> | undefined;
+            boxDecorationBreak?: Property.BoxDecorationBreak | undefined;
+            boxShadow?: Property.BoxShadow | undefined;
+            boxSizing?: Property.BoxSizing | undefined;
+            breakAfter?: Property.BreakAfter | undefined;
+            breakBefore?: Property.BreakBefore | undefined;
+            breakInside?: Property.BreakInside | undefined;
+            captionSide?: Property.CaptionSide | undefined;
+            caretColor?: Property.CaretColor | undefined;
+            caretShape?: Property.CaretShape | undefined;
+            clear?: Property.Clear | undefined;
+            clipPath?: Property.ClipPath | undefined;
+            color?: Property.Color | undefined;
+            colorAdjust?: Property.PrintColorAdjust | undefined;
+            colorScheme?: Property.ColorScheme | undefined;
+            columnCount?: Property.ColumnCount | undefined;
+            columnFill?: Property.ColumnFill | undefined;
+            columnGap?: Property.ColumnGap<string | number> | undefined;
+            columnRuleColor?: Property.ColumnRuleColor | undefined;
+            columnRuleStyle?: Property.ColumnRuleStyle | undefined;
+            columnRuleWidth?: Property.ColumnRuleWidth<string | number> | undefined;
+            columnSpan?: Property.ColumnSpan | undefined;
+            columnWidth?: Property.ColumnWidth<string | number> | undefined;
+            contain?: Property.Contain | undefined;
+            containIntrinsicBlockSize?: Property.ContainIntrinsicBlockSize<string | number> | undefined;
+            containIntrinsicHeight?: Property.ContainIntrinsicHeight<string | number> | undefined;
+            containIntrinsicInlineSize?: Property.ContainIntrinsicInlineSize<string | number> | undefined;
+            containIntrinsicWidth?: Property.ContainIntrinsicWidth<string | number> | undefined;
+            containerName?: Property.ContainerName | undefined;
+            containerType?: Property.ContainerType | undefined;
+            content?: Property.Content | undefined;
+            contentVisibility?: Property.ContentVisibility | undefined;
+            counterIncrement?: Property.CounterIncrement | undefined;
+            counterReset?: Property.CounterReset | undefined;
+            counterSet?: Property.CounterSet | undefined;
+            cursor?: Property.Cursor | undefined;
+            direction?: Property.Direction | undefined;
+            display?: Property.Display | undefined;
+            emptyCells?: Property.EmptyCells | undefined;
+            filter?: Property.Filter | undefined;
+            flexBasis?: Property.FlexBasis<string | number> | undefined;
+            flexDirection?: Property.FlexDirection | undefined;
+            flexGrow?: Property.FlexGrow | undefined;
+            flexShrink?: Property.FlexShrink | undefined;
+            flexWrap?: Property.FlexWrap | undefined;
+            float?: Property.Float | undefined;
+            fontFamily?: Property.FontFamily | undefined;
+            fontFeatureSettings?: Property.FontFeatureSettings | undefined;
+            fontKerning?: Property.FontKerning | undefined;
+            fontLanguageOverride?: Property.FontLanguageOverride | undefined;
+            fontOpticalSizing?: Property.FontOpticalSizing | undefined;
+            fontPalette?: Property.FontPalette | undefined;
+            fontSize?: Property.FontSize<string | number> | undefined;
+            fontSizeAdjust?: Property.FontSizeAdjust | undefined;
+            fontSmooth?: Property.FontSmooth<string | number> | undefined;
+            fontStretch?: Property.FontStretch | undefined;
+            fontStyle?: Property.FontStyle | undefined;
+            fontSynthesis?: Property.FontSynthesis | undefined;
+            fontVariant?: Property.FontVariant | undefined;
+            fontVariantAlternates?: Property.FontVariantAlternates | undefined;
+            fontVariantCaps?: Property.FontVariantCaps | undefined;
+            fontVariantEastAsian?: Property.FontVariantEastAsian | undefined;
+            fontVariantEmoji?: Property.FontVariantEmoji | undefined;
+            fontVariantLigatures?: Property.FontVariantLigatures | undefined;
+            fontVariantNumeric?: Property.FontVariantNumeric | undefined;
+            fontVariantPosition?: Property.FontVariantPosition | undefined;
+            fontVariationSettings?: Property.FontVariationSettings | undefined;
+            fontWeight?: Property.FontWeight | undefined;
+            forcedColorAdjust?: Property.ForcedColorAdjust | undefined;
+            gridAutoColumns?: Property.GridAutoColumns<string | number> | undefined;
+            gridAutoFlow?: Property.GridAutoFlow | undefined;
+            gridAutoRows?: Property.GridAutoRows<string | number> | undefined;
+            gridColumnEnd?: Property.GridColumnEnd | undefined;
+            gridColumnStart?: Property.GridColumnStart | undefined;
+            gridRowEnd?: Property.GridRowEnd | undefined;
+            gridRowStart?: Property.GridRowStart | undefined;
+            gridTemplateAreas?: Property.GridTemplateAreas | undefined;
+            gridTemplateColumns?: Property.GridTemplateColumns<string | number> | undefined;
+            gridTemplateRows?: Property.GridTemplateRows<string | number> | undefined;
+            hangingPunctuation?: Property.HangingPunctuation | undefined;
+            height?: Property.Height<string | number> | undefined;
+            hyphenateCharacter?: Property.HyphenateCharacter | undefined;
+            hyphenateLimitChars?: Property.HyphenateLimitChars | undefined;
+            hyphens?: Property.Hyphens | undefined;
+            imageOrientation?: Property.ImageOrientation | undefined;
+            imageRendering?: Property.ImageRendering | undefined;
+            imageResolution?: Property.ImageResolution | undefined;
+            initialLetter?: Property.InitialLetter | undefined;
+            inlineSize?: Property.InlineSize<string | number> | undefined;
+            inputSecurity?: Property.InputSecurity | undefined;
+            insetBlockEnd?: Property.InsetBlockEnd<string | number> | undefined;
+            insetBlockStart?: Property.InsetBlockStart<string | number> | undefined;
+            insetInlineEnd?: Property.InsetInlineEnd<string | number> | undefined;
+            insetInlineStart?: Property.InsetInlineStart<string | number> | undefined;
+            isolation?: Property.Isolation | undefined;
+            justifyContent?: Property.JustifyContent | undefined;
+            justifyItems?: Property.JustifyItems | undefined;
+            justifySelf?: Property.JustifySelf | undefined;
+            justifyTracks?: Property.JustifyTracks | undefined;
+            left?: Property.Left<string | number> | undefined;
+            letterSpacing?: Property.LetterSpacing<string | number> | undefined;
+            lineBreak?: Property.LineBreak | undefined;
+            lineHeight?: Property.LineHeight<string | number> | undefined;
+            lineHeightStep?: Property.LineHeightStep<string | number> | undefined;
+            listStyleImage?: Property.ListStyleImage | undefined;
+            listStylePosition?: Property.ListStylePosition | undefined;
+            listStyleType?: Property.ListStyleType | undefined;
+            marginBlockEnd?: Property.MarginBlockEnd<string | number> | undefined;
+            marginBlockStart?: Property.MarginBlockStart<string | number> | undefined;
+            marginBottom?: Property.MarginBottom<string | number> | undefined;
+            marginInlineEnd?: Property.MarginInlineEnd<string | number> | undefined;
+            marginInlineStart?: Property.MarginInlineStart<string | number> | undefined;
+            marginLeft?: Property.MarginLeft<string | number> | undefined;
+            marginRight?: Property.MarginRight<string | number> | undefined;
+            marginTop?: Property.MarginTop<string | number> | undefined;
+            marginTrim?: Property.MarginTrim | undefined;
+            maskBorderMode?: Property.MaskBorderMode | undefined;
+            maskBorderOutset?: Property.MaskBorderOutset<string | number> | undefined;
+            maskBorderRepeat?: Property.MaskBorderRepeat | undefined;
+            maskBorderSlice?: Property.MaskBorderSlice | undefined;
+            maskBorderSource?: Property.MaskBorderSource | undefined;
+            maskBorderWidth?: Property.MaskBorderWidth<string | number> | undefined;
+            maskClip?: Property.MaskClip | undefined;
+            maskComposite?: Property.MaskComposite | undefined;
+            maskImage?: Property.MaskImage | undefined;
+            maskMode?: Property.MaskMode | undefined;
+            maskOrigin?: Property.MaskOrigin | undefined;
+            maskPosition?: Property.MaskPosition<string | number> | undefined;
+            maskRepeat?: Property.MaskRepeat | undefined;
+            maskSize?: Property.MaskSize<string | number> | undefined;
+            maskType?: Property.MaskType | undefined;
+            mathDepth?: Property.MathDepth | undefined;
+            mathShift?: Property.MathShift | undefined;
+            mathStyle?: Property.MathStyle | undefined;
+            maxBlockSize?: Property.MaxBlockSize<string | number> | undefined;
+            maxHeight?: Property.MaxHeight<string | number> | undefined;
+            maxInlineSize?: Property.MaxInlineSize<string | number> | undefined;
+            maxLines?: Property.MaxLines | undefined;
+            maxWidth?: Property.MaxWidth<string | number> | undefined;
+            minBlockSize?: Property.MinBlockSize<string | number> | undefined;
+            minHeight?: Property.MinHeight<string | number> | undefined;
+            minInlineSize?: Property.MinInlineSize<string | number> | undefined;
+            minWidth?: Property.MinWidth<string | number> | undefined;
+            mixBlendMode?: Property.MixBlendMode | undefined;
+            motionDistance?: Property.OffsetDistance<string | number> | undefined;
+            motionPath?: Property.OffsetPath | undefined;
+            motionRotation?: Property.OffsetRotate | undefined;
+            objectFit?: Property.ObjectFit | undefined;
+            objectPosition?: Property.ObjectPosition<string | number> | undefined;
+            offsetAnchor?: Property.OffsetAnchor<string | number> | undefined;
+            offsetDistance?: Property.OffsetDistance<string | number> | undefined;
+            offsetPath?: Property.OffsetPath | undefined;
+            offsetPosition?: Property.OffsetPosition<string | number> | undefined;
+            offsetRotate?: Property.OffsetRotate | undefined;
+            offsetRotation?: Property.OffsetRotate | undefined;
+            opacity?: Property.Opacity | undefined;
+            order?: Property.Order | undefined;
+            orphans?: Property.Orphans | undefined;
+            outlineColor?: Property.OutlineColor | undefined;
+            outlineOffset?: Property.OutlineOffset<string | number> | undefined;
+            outlineStyle?: Property.OutlineStyle | undefined;
+            outlineWidth?: Property.OutlineWidth<string | number> | undefined;
+            overflowAnchor?: Property.OverflowAnchor | undefined;
+            overflowBlock?: Property.OverflowBlock | undefined;
+            overflowClipBox?: Property.OverflowClipBox | undefined;
+            overflowClipMargin?: Property.OverflowClipMargin<string | number> | undefined;
+            overflowInline?: Property.OverflowInline | undefined;
+            overflowWrap?: Property.OverflowWrap | undefined;
+            overflowX?: Property.OverflowX | undefined;
+            overflowY?: Property.OverflowY | undefined;
+            overscrollBehaviorBlock?: Property.OverscrollBehaviorBlock | undefined;
+            overscrollBehaviorInline?: Property.OverscrollBehaviorInline | undefined;
+            overscrollBehaviorX?: Property.OverscrollBehaviorX | undefined;
+            overscrollBehaviorY?: Property.OverscrollBehaviorY | undefined;
+            paddingBlockEnd?: Property.PaddingBlockEnd<string | number> | undefined;
+            paddingBlockStart?: Property.PaddingBlockStart<string | number> | undefined;
+            paddingBottom?: Property.PaddingBottom<string | number> | undefined;
+            paddingInlineEnd?: Property.PaddingInlineEnd<string | number> | undefined;
+            paddingInlineStart?: Property.PaddingInlineStart<string | number> | undefined;
+            paddingLeft?: Property.PaddingLeft<string | number> | undefined;
+            paddingRight?: Property.PaddingRight<string | number> | undefined;
+            paddingTop?: Property.PaddingTop<string | number> | undefined;
+            page?: Property.Page | undefined;
+            pageBreakAfter?: Property.PageBreakAfter | undefined;
+            pageBreakBefore?: Property.PageBreakBefore | undefined;
+            pageBreakInside?: Property.PageBreakInside | undefined;
+            paintOrder?: Property.PaintOrder | undefined;
+            perspective?: Property.Perspective<string | number> | undefined;
+            perspectiveOrigin?: Property.PerspectiveOrigin<string | number> | undefined;
+            pointerEvents?: Property.PointerEvents | undefined;
+            position?: Property.Position | undefined;
+            printColorAdjust?: Property.PrintColorAdjust | undefined;
+            quotes?: Property.Quotes | undefined;
+            resize?: Property.Resize | undefined;
+            right?: Property.Right<string | number> | undefined;
+            rotate?: Property.Rotate | undefined;
+            rowGap?: Property.RowGap<string | number> | undefined;
+            rubyAlign?: Property.RubyAlign | undefined;
+            rubyMerge?: Property.RubyMerge | undefined;
+            rubyPosition?: Property.RubyPosition | undefined;
+            scale?: Property.Scale | undefined;
+            scrollBehavior?: Property.ScrollBehavior | undefined;
+            scrollMarginBlockEnd?: Property.ScrollMarginBlockEnd<string | number> | undefined;
+            scrollMarginBlockStart?: Property.ScrollMarginBlockStart<string | number> | undefined;
+            scrollMarginBottom?: Property.ScrollMarginBottom<string | number> | undefined;
+            scrollMarginInlineEnd?: Property.ScrollMarginInlineEnd<string | number> | undefined;
+            scrollMarginInlineStart?: Property.ScrollMarginInlineStart<string | number> | undefined;
+            scrollMarginLeft?: Property.ScrollMarginLeft<string | number> | undefined;
+            scrollMarginRight?: Property.ScrollMarginRight<string | number> | undefined;
+            scrollMarginTop?: Property.ScrollMarginTop<string | number> | undefined;
+            scrollPaddingBlockEnd?: Property.ScrollPaddingBlockEnd<string | number> | undefined;
+            scrollPaddingBlockStart?: Property.ScrollPaddingBlockStart<string | number> | undefined;
+            scrollPaddingBottom?: Property.ScrollPaddingBottom<string | number> | undefined;
+            scrollPaddingInlineEnd?: Property.ScrollPaddingInlineEnd<string | number> | undefined;
+            scrollPaddingInlineStart?: Property.ScrollPaddingInlineStart<string | number> | undefined;
+            scrollPaddingLeft?: Property.ScrollPaddingLeft<string | number> | undefined;
+            scrollPaddingRight?: Property.ScrollPaddingRight<string | number> | undefined;
+            scrollPaddingTop?: Property.ScrollPaddingTop<string | number> | undefined;
+            scrollSnapAlign?: Property.ScrollSnapAlign | undefined;
+            scrollSnapMarginBottom?: Property.ScrollMarginBottom<string | number> | undefined;
+            scrollSnapMarginLeft?: Property.ScrollMarginLeft<string | number> | undefined;
+            scrollSnapMarginRight?: Property.ScrollMarginRight<string | number> | undefined;
+            scrollSnapMarginTop?: Property.ScrollMarginTop<string | number> | undefined;
+            scrollSnapStop?: Property.ScrollSnapStop | undefined;
+            scrollSnapType?: Property.ScrollSnapType | undefined;
+            scrollTimelineAxis?: Property.ScrollTimelineAxis | undefined;
+            scrollTimelineName?: Property.ScrollTimelineName | undefined;
+            scrollbarColor?: Property.ScrollbarColor | undefined;
+            scrollbarGutter?: Property.ScrollbarGutter | undefined;
+            scrollbarWidth?: Property.ScrollbarWidth | undefined;
+            shapeImageThreshold?: Property.ShapeImageThreshold | undefined;
+            shapeMargin?: Property.ShapeMargin<string | number> | undefined;
+            shapeOutside?: Property.ShapeOutside | undefined;
+            tabSize?: Property.TabSize<string | number> | undefined;
+            tableLayout?: Property.TableLayout | undefined;
+            textAlign?: Property.TextAlign | undefined;
+            textAlignLast?: Property.TextAlignLast | undefined;
+            textCombineUpright?: Property.TextCombineUpright | undefined;
+            textDecorationColor?: Property.TextDecorationColor | undefined;
+            textDecorationLine?: Property.TextDecorationLine | undefined;
+            textDecorationSkip?: Property.TextDecorationSkip | undefined;
+            textDecorationSkipInk?: Property.TextDecorationSkipInk | undefined;
+            textDecorationStyle?: Property.TextDecorationStyle | undefined;
+            textDecorationThickness?: Property.TextDecorationThickness<string | number> | undefined;
+            textEmphasisColor?: Property.TextEmphasisColor | undefined;
+            textEmphasisPosition?: Property.TextEmphasisPosition | undefined;
+            textEmphasisStyle?: Property.TextEmphasisStyle | undefined;
+            textIndent?: Property.TextIndent<string | number> | undefined;
+            textJustify?: Property.TextJustify | undefined;
+            textOrientation?: Property.TextOrientation | undefined;
+            textOverflow?: Property.TextOverflow | undefined;
+            textRendering?: Property.TextRendering | undefined;
+            textShadow?: Property.TextShadow | undefined;
+            textSizeAdjust?: Property.TextSizeAdjust | undefined;
+            textTransform?: Property.TextTransform | undefined;
+            textUnderlineOffset?: Property.TextUnderlineOffset<string | number> | undefined;
+            textUnderlinePosition?: Property.TextUnderlinePosition | undefined;
+            top?: Property.Top<string | number> | undefined;
+            touchAction?: Property.TouchAction | undefined;
+            transform?: Property.Transform | undefined;
+            transformBox?: Property.TransformBox | undefined;
+            transformOrigin?: Property.TransformOrigin<string | number> | undefined;
+            transformStyle?: Property.TransformStyle | undefined;
+            transitionDelay?: Property.TransitionDelay<string & {}> | undefined;
+            transitionDuration?: Property.TransitionDuration<string & {}> | undefined;
+            transitionProperty?: Property.TransitionProperty | undefined;
+            transitionTimingFunction?: Property.TransitionTimingFunction | undefined;
+            translate?: Property.Translate<string | number> | undefined;
+            unicodeBidi?: Property.UnicodeBidi | undefined;
+            userSelect?: Property.UserSelect | undefined;
+            verticalAlign?: Property.VerticalAlign<string | number> | undefined;
+            viewTransitionName?: Property.ViewTransitionName | undefined;
+            visibility?: Property.Visibility | undefined;
+            whiteSpace?: Property.WhiteSpace | undefined;
+            widows?: Property.Widows | undefined;
+            width?: Property.Width<string | number> | undefined;
+            willChange?: Property.WillChange | undefined;
+            wordBreak?: Property.WordBreak | undefined;
+            wordSpacing?: Property.WordSpacing<string | number> | undefined;
+            wordWrap?: Property.WordWrap | undefined;
+            writingMode?: Property.WritingMode | undefined;
+            zIndex?: Property.ZIndex | undefined;
+            zoom?: Property.Zoom | undefined;
+            all?: Property.All | undefined;
+            animation?: Property.Animation<string & {}> | undefined;
+            background?: Property.Background<string | number> | undefined;
+            backgroundPosition?: Property.BackgroundPosition<string | number> | undefined;
+            border?: Property.Border<string | number> | undefined;
+            borderBlock?: Property.BorderBlock<string | number> | undefined;
+            borderBlockEnd?: Property.BorderBlockEnd<string | number> | undefined;
+            borderBlockStart?: Property.BorderBlockStart<string | number> | undefined;
+            borderBottom?: Property.BorderBottom<string | number> | undefined;
+            borderColor?: Property.BorderColor | undefined;
+            borderImage?: Property.BorderImage | undefined;
+            borderInline?: Property.BorderInline<string | number> | undefined;
+            borderInlineEnd?: Property.BorderInlineEnd<string | number> | undefined;
+            borderInlineStart?: Property.BorderInlineStart<string | number> | undefined;
+            borderLeft?: Property.BorderLeft<string | number> | undefined;
+            borderRadius?: Property.BorderRadius<string | number> | undefined;
+            borderRight?: Property.BorderRight<string | number> | undefined;
+            borderStyle?: Property.BorderStyle | undefined;
+            borderTop?: Property.BorderTop<string | number> | undefined;
+            borderWidth?: Property.BorderWidth<string | number> | undefined;
+            caret?: Property.Caret | undefined;
+            columnRule?: Property.ColumnRule<string | number> | undefined;
+            columns?: Property.Columns<string | number> | undefined;
+            containIntrinsicSize?: Property.ContainIntrinsicSize<string | number> | undefined;
+            container?: Property.Container | undefined;
+            flex?: Property.Flex<string | number> | undefined;
+            flexFlow?: Property.FlexFlow | undefined;
+            font?: Property.Font | undefined;
+            gap?: Property.Gap<string | number> | undefined;
+            grid?: Property.Grid | undefined;
+            gridArea?: Property.GridArea | undefined;
+            gridColumn?: Property.GridColumn | undefined;
+            gridRow?: Property.GridRow | undefined;
+            gridTemplate?: Property.GridTemplate | undefined;
+            inset?: Property.Inset<string | number> | undefined;
+            insetBlock?: Property.InsetBlock<string | number> | undefined;
+            insetInline?: Property.InsetInline<string | number> | undefined;
+            lineClamp?: Property.LineClamp | undefined;
+            listStyle?: Property.ListStyle | undefined;
+            margin?: Property.Margin<string | number> | undefined;
+            marginBlock?: Property.MarginBlock<string | number> | undefined;
+            marginInline?: Property.MarginInline<string | number> | undefined;
+            mask?: Property.Mask<string | number> | undefined;
+            maskBorder?: Property.MaskBorder | undefined;
+            motion?: Property.Offset<string | number> | undefined;
+            offset?: Property.Offset<string | number> | undefined;
+            outline?: Property.Outline<string | number> | undefined;
+            overflow?: Property.Overflow | undefined;
+            overscrollBehavior?: Property.OverscrollBehavior | undefined;
+            padding?: Property.Padding<string | number> | undefined;
+            paddingBlock?: Property.PaddingBlock<string | number> | undefined;
+            paddingInline?: Property.PaddingInline<string | number> | undefined;
+            placeContent?: Property.PlaceContent | undefined;
+            placeItems?: Property.PlaceItems | undefined;
+            placeSelf?: Property.PlaceSelf | undefined;
+            scrollMargin?: Property.ScrollMargin<string | number> | undefined;
+            scrollMarginBlock?: Property.ScrollMarginBlock<string | number> | undefined;
+            scrollMarginInline?: Property.ScrollMarginInline<string | number> | undefined;
+            scrollPadding?: Property.ScrollPadding<string | number> | undefined;
+            scrollPaddingBlock?: Property.ScrollPaddingBlock<string | number> | undefined;
+            scrollPaddingInline?: Property.ScrollPaddingInline<string | number> | undefined;
+            scrollSnapMargin?: Property.ScrollMargin<string | number> | undefined;
+            scrollTimeline?: Property.ScrollTimeline | undefined;
+            textDecoration?: Property.TextDecoration<string | number> | undefined;
+            textEmphasis?: Property.TextEmphasis | undefined;
+            transition?: Property.Transition<string & {}> | undefined;
+            MozAnimationDelay?: Property.AnimationDelay<string & {}> | undefined;
+            MozAnimationDirection?: Property.AnimationDirection | undefined;
+            MozAnimationDuration?: Property.AnimationDuration<string & {}> | undefined;
+            MozAnimationFillMode?: Property.AnimationFillMode | undefined;
+            MozAnimationIterationCount?: Property.AnimationIterationCount | undefined;
+            MozAnimationName?: Property.AnimationName | undefined;
+            MozAnimationPlayState?: Property.AnimationPlayState | undefined;
+            MozAnimationTimingFunction?: Property.AnimationTimingFunction | undefined;
+            MozAppearance?: Property.MozAppearance | undefined;
+            MozBackfaceVisibility?: Property.BackfaceVisibility | undefined;
+            MozBinding?: Property.MozBinding | undefined;
+            MozBorderBottomColors?: Property.MozBorderBottomColors | undefined;
+            MozBorderEndColor?: Property.BorderInlineEndColor | undefined;
+            MozBorderEndStyle?: Property.BorderInlineEndStyle | undefined;
+            MozBorderEndWidth?: Property.BorderInlineEndWidth<string | number> | undefined;
+            MozBorderLeftColors?: Property.MozBorderLeftColors | undefined;
+            MozBorderRightColors?: Property.MozBorderRightColors | undefined;
+            MozBorderStartColor?: Property.BorderInlineStartColor | undefined;
+            MozBorderStartStyle?: Property.BorderInlineStartStyle | undefined;
+            MozBorderTopColors?: Property.MozBorderTopColors | undefined;
+            MozBoxSizing?: Property.BoxSizing | undefined;
+            MozColumnCount?: Property.ColumnCount | undefined;
+            MozColumnFill?: Property.ColumnFill | undefined;
+            MozColumnRuleColor?: Property.ColumnRuleColor | undefined;
+            MozColumnRuleStyle?: Property.ColumnRuleStyle | undefined;
+            MozColumnRuleWidth?: Property.ColumnRuleWidth<string | number> | undefined;
+            MozColumnWidth?: Property.ColumnWidth<string | number> | undefined;
+            MozContextProperties?: Property.MozContextProperties | undefined;
+            MozFontFeatureSettings?: Property.FontFeatureSettings | undefined;
+            MozFontLanguageOverride?: Property.FontLanguageOverride | undefined;
+            MozHyphens?: Property.Hyphens | undefined;
+            MozImageRegion?: Property.MozImageRegion | undefined;
+            MozMarginEnd?: Property.MarginInlineEnd<string | number> | undefined;
+            MozMarginStart?: Property.MarginInlineStart<string | number> | undefined;
+            MozOrient?: Property.MozOrient | undefined;
+            MozOsxFontSmoothing?: Property.FontSmooth<string | number> | undefined;
+            MozPaddingEnd?: Property.PaddingInlineEnd<string | number> | undefined;
+            MozPaddingStart?: Property.PaddingInlineStart<string | number> | undefined;
+            MozPerspective?: Property.Perspective<string | number> | undefined;
+            MozPerspectiveOrigin?: Property.PerspectiveOrigin<string | number> | undefined;
+            MozStackSizing?: Property.MozStackSizing | undefined;
+            MozTabSize?: Property.TabSize<string | number> | undefined;
+            MozTextBlink?: Property.MozTextBlink | undefined;
+            MozTextSizeAdjust?: Property.TextSizeAdjust | undefined;
+            MozTransformOrigin?: Property.TransformOrigin<string | number> | undefined;
+            MozTransformStyle?: Property.TransformStyle | undefined;
+            MozTransitionDelay?: Property.TransitionDelay<string & {}> | undefined;
+            MozTransitionDuration?: Property.TransitionDuration<string & {}> | undefined;
+            MozTransitionProperty?: Property.TransitionProperty | undefined;
+            MozTransitionTimingFunction?: Property.TransitionTimingFunction | undefined;
+            MozUserFocus?: Property.MozUserFocus | undefined;
+            MozUserModify?: Property.MozUserModify | undefined;
+            MozUserSelect?: Property.UserSelect | undefined;
+            MozWindowDragging?: Property.MozWindowDragging | undefined;
+            MozWindowShadow?: Property.MozWindowShadow | undefined;
+            msAccelerator?: Property.MsAccelerator | undefined;
+            msBlockProgression?: Property.MsBlockProgression | undefined;
+            msContentZoomChaining?: Property.MsContentZoomChaining | undefined;
+            msContentZoomLimitMax?: Property.MsContentZoomLimitMax | undefined;
+            msContentZoomLimitMin?: Property.MsContentZoomLimitMin | undefined;
+            msContentZoomSnapPoints?: Property.MsContentZoomSnapPoints | undefined;
+            msContentZoomSnapType?: Property.MsContentZoomSnapType | undefined;
+            msContentZooming?: Property.MsContentZooming | undefined;
+            msFilter?: Property.MsFilter | undefined;
+            msFlexDirection?: Property.FlexDirection | undefined;
+            msFlexPositive?: Property.FlexGrow | undefined;
+            msFlowFrom?: Property.MsFlowFrom | undefined;
+            msFlowInto?: Property.MsFlowInto | undefined;
+            msGridColumns?: Property.MsGridColumns<string | number> | undefined;
+            msGridRows?: Property.MsGridRows<string | number> | undefined;
+            msHighContrastAdjust?: Property.MsHighContrastAdjust | undefined;
+            msHyphenateLimitChars?: Property.MsHyphenateLimitChars | undefined;
+            msHyphenateLimitLines?: Property.MsHyphenateLimitLines | undefined;
+            msHyphenateLimitZone?: Property.MsHyphenateLimitZone<string | number> | undefined;
+            msHyphens?: Property.Hyphens | undefined;
+            msImeAlign?: Property.MsImeAlign | undefined;
+            msLineBreak?: Property.LineBreak | undefined;
+            msOrder?: Property.Order | undefined;
+            msOverflowStyle?: Property.MsOverflowStyle | undefined;
+            msOverflowX?: Property.OverflowX | undefined;
+            msOverflowY?: Property.OverflowY | undefined;
+            msScrollChaining?: Property.MsScrollChaining | undefined;
+            msScrollLimitXMax?: Property.MsScrollLimitXMax<string | number> | undefined;
+            msScrollLimitXMin?: Property.MsScrollLimitXMin<string | number> | undefined;
+            msScrollLimitYMax?: Property.MsScrollLimitYMax<string | number> | undefined;
+            msScrollLimitYMin?: Property.MsScrollLimitYMin<string | number> | undefined;
+            msScrollRails?: Property.MsScrollRails | undefined;
+            msScrollSnapPointsX?: Property.MsScrollSnapPointsX | undefined;
+            msScrollSnapPointsY?: Property.MsScrollSnapPointsY | undefined;
+            msScrollSnapType?: Property.MsScrollSnapType | undefined;
+            msScrollTranslation?: Property.MsScrollTranslation | undefined;
+            msScrollbar3dlightColor?: Property.MsScrollbar3dlightColor | undefined;
+            msScrollbarArrowColor?: Property.MsScrollbarArrowColor | undefined;
+            msScrollbarBaseColor?: Property.MsScrollbarBaseColor | undefined;
+            msScrollbarDarkshadowColor?: Property.MsScrollbarDarkshadowColor | undefined;
+            msScrollbarFaceColor?: Property.MsScrollbarFaceColor | undefined;
+            msScrollbarHighlightColor?: Property.MsScrollbarHighlightColor | undefined;
+            msScrollbarShadowColor?: Property.MsScrollbarShadowColor | undefined;
+            msScrollbarTrackColor?: Property.MsScrollbarTrackColor | undefined;
+            msTextAutospace?: Property.MsTextAutospace | undefined;
+            msTextCombineHorizontal?: Property.TextCombineUpright | undefined;
+            msTextOverflow?: Property.TextOverflow | undefined;
+            msTouchAction?: Property.TouchAction | undefined;
+            msTouchSelect?: Property.MsTouchSelect | undefined;
+            msTransform?: Property.Transform | undefined;
+            msTransformOrigin?: Property.TransformOrigin<string | number> | undefined;
+            msTransitionDelay?: Property.TransitionDelay<string & {}> | undefined;
+            msTransitionDuration?: Property.TransitionDuration<string & {}> | undefined;
+            msTransitionProperty?: Property.TransitionProperty | undefined;
+            msTransitionTimingFunction?: Property.TransitionTimingFunction | undefined;
+            msUserSelect?: Property.MsUserSelect | undefined;
+            msWordBreak?: Property.WordBreak | undefined;
+            msWrapFlow?: Property.MsWrapFlow | undefined;
+            msWrapMargin?: Property.MsWrapMargin<string | number> | undefined;
+            msWrapThrough?: Property.MsWrapThrough | undefined;
+            msWritingMode?: Property.WritingMode | undefined;
+            WebkitAlignContent?: Property.AlignContent | undefined;
+            WebkitAlignItems?: Property.AlignItems | undefined;
+            WebkitAlignSelf?: Property.AlignSelf | undefined;
+            WebkitAnimationDelay?: Property.AnimationDelay<string & {}> | undefined;
+            WebkitAnimationDirection?: Property.AnimationDirection | undefined;
+            WebkitAnimationDuration?: Property.AnimationDuration<string & {}> | undefined;
+            WebkitAnimationFillMode?: Property.AnimationFillMode | undefined;
+            WebkitAnimationIterationCount?: Property.AnimationIterationCount | undefined;
+            WebkitAnimationName?: Property.AnimationName | undefined;
+            WebkitAnimationPlayState?: Property.AnimationPlayState | undefined;
+            WebkitAnimationTimingFunction?: Property.AnimationTimingFunction | undefined;
+            WebkitAppearance?: Property.WebkitAppearance | undefined;
+            WebkitBackdropFilter?: Property.BackdropFilter | undefined;
+            WebkitBackfaceVisibility?: Property.BackfaceVisibility | undefined;
+            WebkitBackgroundClip?: Property.BackgroundClip | undefined;
+            WebkitBackgroundOrigin?: Property.BackgroundOrigin | undefined;
+            WebkitBackgroundSize?: Property.BackgroundSize<string | number> | undefined;
+            WebkitBorderBeforeColor?: Property.WebkitBorderBeforeColor | undefined;
+            WebkitBorderBeforeStyle?: Property.WebkitBorderBeforeStyle | undefined;
+            WebkitBorderBeforeWidth?: Property.WebkitBorderBeforeWidth<string | number> | undefined;
+            WebkitBorderBottomLeftRadius?: Property.BorderBottomLeftRadius<string | number> | undefined;
+            WebkitBorderBottomRightRadius?: Property.BorderBottomRightRadius<string | number> | undefined;
+            WebkitBorderImageSlice?: Property.BorderImageSlice | undefined;
+            WebkitBorderTopLeftRadius?: Property.BorderTopLeftRadius<string | number> | undefined;
+            WebkitBorderTopRightRadius?: Property.BorderTopRightRadius<string | number> | undefined;
+            WebkitBoxDecorationBreak?: Property.BoxDecorationBreak | undefined;
+            WebkitBoxReflect?: Property.WebkitBoxReflect<string | number> | undefined;
+            WebkitBoxShadow?: Property.BoxShadow | undefined;
+            WebkitBoxSizing?: Property.BoxSizing | undefined;
+            WebkitClipPath?: Property.ClipPath | undefined;
+            WebkitColumnCount?: Property.ColumnCount | undefined;
+            WebkitColumnFill?: Property.ColumnFill | undefined;
+            WebkitColumnRuleColor?: Property.ColumnRuleColor | undefined;
+            WebkitColumnRuleStyle?: Property.ColumnRuleStyle | undefined;
+            WebkitColumnRuleWidth?: Property.ColumnRuleWidth<string | number> | undefined;
+            WebkitColumnSpan?: Property.ColumnSpan | undefined;
+            WebkitColumnWidth?: Property.ColumnWidth<string | number> | undefined;
+            WebkitFilter?: Property.Filter | undefined;
+            WebkitFlexBasis?: Property.FlexBasis<string | number> | undefined;
+            WebkitFlexDirection?: Property.FlexDirection | undefined;
+            WebkitFlexGrow?: Property.FlexGrow | undefined;
+            WebkitFlexShrink?: Property.FlexShrink | undefined;
+            WebkitFlexWrap?: Property.FlexWrap | undefined;
+            WebkitFontFeatureSettings?: Property.FontFeatureSettings | undefined;
+            WebkitFontKerning?: Property.FontKerning | undefined;
+            WebkitFontSmoothing?: Property.FontSmooth<string | number> | undefined;
+            WebkitFontVariantLigatures?: Property.FontVariantLigatures | undefined;
+            WebkitHyphenateCharacter?: Property.HyphenateCharacter | undefined;
+            WebkitHyphens?: Property.Hyphens | undefined;
+            WebkitInitialLetter?: Property.InitialLetter | undefined;
+            WebkitJustifyContent?: Property.JustifyContent | undefined;
+            WebkitLineBreak?: Property.LineBreak | undefined;
+            WebkitLineClamp?: Property.WebkitLineClamp | undefined;
+            WebkitMarginEnd?: Property.MarginInlineEnd<string | number> | undefined;
+            WebkitMarginStart?: Property.MarginInlineStart<string | number> | undefined;
+            WebkitMaskAttachment?: Property.WebkitMaskAttachment | undefined;
+            WebkitMaskBoxImageOutset?: Property.MaskBorderOutset<string | number> | undefined;
+            WebkitMaskBoxImageRepeat?: Property.MaskBorderRepeat | undefined;
+            WebkitMaskBoxImageSlice?: Property.MaskBorderSlice | undefined;
+            WebkitMaskBoxImageSource?: Property.MaskBorderSource | undefined;
+            WebkitMaskBoxImageWidth?: Property.MaskBorderWidth<string | number> | undefined;
+            WebkitMaskClip?: Property.WebkitMaskClip | undefined;
+            WebkitMaskComposite?: Property.WebkitMaskComposite | undefined;
+            WebkitMaskImage?: Property.WebkitMaskImage | undefined;
+            WebkitMaskOrigin?: Property.WebkitMaskOrigin | undefined;
+            WebkitMaskPosition?: Property.WebkitMaskPosition<string | number> | undefined;
+            WebkitMaskPositionX?: Property.WebkitMaskPositionX<string | number> | undefined;
+            WebkitMaskPositionY?: Property.WebkitMaskPositionY<string | number> | undefined;
+            WebkitMaskRepeat?: Property.WebkitMaskRepeat | undefined;
+            WebkitMaskRepeatX?: Property.WebkitMaskRepeatX | undefined;
+            WebkitMaskRepeatY?: Property.WebkitMaskRepeatY | undefined;
+            WebkitMaskSize?: Property.WebkitMaskSize<string | number> | undefined;
+            WebkitMaxInlineSize?: Property.MaxInlineSize<string | number> | undefined;
+            WebkitOrder?: Property.Order | undefined;
+            WebkitOverflowScrolling?: Property.WebkitOverflowScrolling | undefined;
+            WebkitPaddingEnd?: Property.PaddingInlineEnd<string | number> | undefined;
+            WebkitPaddingStart?: Property.PaddingInlineStart<string | number> | undefined;
+            WebkitPerspective?: Property.Perspective<string | number> | undefined;
+            WebkitPerspectiveOrigin?: Property.PerspectiveOrigin<string | number> | undefined;
+            WebkitPrintColorAdjust?: Property.PrintColorAdjust | undefined;
+            WebkitRubyPosition?: Property.RubyPosition | undefined;
+            WebkitScrollSnapType?: Property.ScrollSnapType | undefined;
+            WebkitShapeMargin?: Property.ShapeMargin<string | number> | undefined;
+            WebkitTapHighlightColor?: Property.WebkitTapHighlightColor | undefined;
+            WebkitTextCombine?: Property.TextCombineUpright | undefined;
+            WebkitTextDecorationColor?: Property.TextDecorationColor | undefined;
+            WebkitTextDecorationLine?: Property.TextDecorationLine | undefined;
+            WebkitTextDecorationSkip?: Property.TextDecorationSkip | undefined;
+            WebkitTextDecorationStyle?: Property.TextDecorationStyle | undefined;
+            WebkitTextEmphasisColor?: Property.TextEmphasisColor | undefined;
+            WebkitTextEmphasisPosition?: Property.TextEmphasisPosition | undefined;
+            WebkitTextEmphasisStyle?: Property.TextEmphasisStyle | undefined;
+            WebkitTextFillColor?: Property.WebkitTextFillColor | undefined;
+            WebkitTextOrientation?: Property.TextOrientation | undefined;
+            WebkitTextSizeAdjust?: Property.TextSizeAdjust | undefined;
+            WebkitTextStrokeColor?: Property.WebkitTextStrokeColor | undefined;
+            WebkitTextStrokeWidth?: Property.WebkitTextStrokeWidth<string | number> | undefined;
+            WebkitTextUnderlinePosition?: Property.TextUnderlinePosition | undefined;
+            WebkitTouchCallout?: Property.WebkitTouchCallout | undefined;
+            WebkitTransform?: Property.Transform | undefined;
+            WebkitTransformOrigin?: Property.TransformOrigin<string | number> | undefined;
+            WebkitTransformStyle?: Property.TransformStyle | undefined;
+            WebkitTransitionDelay?: Property.TransitionDelay<string & {}> | undefined;
+            WebkitTransitionDuration?: Property.TransitionDuration<string & {}> | undefined;
+            WebkitTransitionProperty?: Property.TransitionProperty | undefined;
+            WebkitTransitionTimingFunction?: Property.TransitionTimingFunction | undefined;
+            WebkitUserModify?: Property.WebkitUserModify | undefined;
+            WebkitUserSelect?: Property.UserSelect | undefined;
+            WebkitWritingMode?: Property.WritingMode | undefined;
+            MozAnimation?: Property.Animation<string & {}> | undefined;
+            MozBorderImage?: Property.BorderImage | undefined;
+            MozColumnRule?: Property.ColumnRule<string | number> | undefined;
+            MozColumns?: Property.Columns<string | number> | undefined;
+            MozTransition?: Property.Transition<string & {}> | undefined;
+            msContentZoomLimit?: Property.MsContentZoomLimit | undefined;
+            msContentZoomSnap?: Property.MsContentZoomSnap | undefined;
+            msFlex?: Property.Flex<string | number> | undefined;
+            msScrollLimit?: Property.MsScrollLimit | undefined;
+            msScrollSnapX?: Property.MsScrollSnapX | undefined;
+            msScrollSnapY?: Property.MsScrollSnapY | undefined;
+            msTransition?: Property.Transition<string & {}> | undefined;
+            WebkitAnimation?: Property.Animation<string & {}> | undefined;
+            WebkitBorderBefore?: Property.WebkitBorderBefore<string | number> | undefined;
+            WebkitBorderImage?: Property.BorderImage | undefined;
+            WebkitBorderRadius?: Property.BorderRadius<string | number> | undefined;
+            WebkitColumnRule?: Property.ColumnRule<string | number> | undefined;
+            WebkitColumns?: Property.Columns<string | number> | undefined;
+            WebkitFlex?: Property.Flex<string | number> | undefined;
+            WebkitFlexFlow?: Property.FlexFlow | undefined;
+            WebkitMask?: Property.WebkitMask<string | number> | undefined;
+            WebkitMaskBoxImage?: Property.MaskBorder | undefined;
+            WebkitTextEmphasis?: Property.TextEmphasis | undefined;
+            WebkitTextStroke?: Property.WebkitTextStroke<string | number> | undefined;
+            WebkitTransition?: Property.Transition<string & {}> | undefined;
+            azimuth?: Property.Azimuth | undefined;
+            boxAlign?: Property.BoxAlign | undefined;
+            boxDirection?: Property.BoxDirection | undefined;
+            boxFlex?: Property.BoxFlex | undefined;
+            boxFlexGroup?: Property.BoxFlexGroup | undefined;
+            boxLines?: Property.BoxLines | undefined;
+            boxOrdinalGroup?: Property.BoxOrdinalGroup | undefined;
+            boxOrient?: Property.BoxOrient | undefined;
+            boxPack?: Property.BoxPack | undefined;
+            clip?: Property.Clip | undefined;
+            gridColumnGap?: Property.GridColumnGap<string | number> | undefined;
+            gridGap?: Property.GridGap<string | number> | undefined;
+            gridRowGap?: Property.GridRowGap<string | number> | undefined;
+            imeMode?: Property.ImeMode | undefined;
+            offsetBlock?: Property.InsetBlock<string | number> | undefined;
+            offsetBlockEnd?: Property.InsetBlockEnd<string | number> | undefined;
+            offsetBlockStart?: Property.InsetBlockStart<string | number> | undefined;
+            offsetInline?: Property.InsetInline<string | number> | undefined;
+            offsetInlineEnd?: Property.InsetInlineEnd<string | number> | undefined;
+            offsetInlineStart?: Property.InsetInlineStart<string | number> | undefined;
+            scrollSnapCoordinate?: Property.ScrollSnapCoordinate<string | number> | undefined;
+            scrollSnapDestination?: Property.ScrollSnapDestination<string | number> | undefined;
+            scrollSnapPointsX?: Property.ScrollSnapPointsX | undefined;
+            scrollSnapPointsY?: Property.ScrollSnapPointsY | undefined;
+            scrollSnapTypeX?: Property.ScrollSnapTypeX | undefined;
+            scrollSnapTypeY?: Property.ScrollSnapTypeY | undefined;
+            KhtmlBoxAlign?: Property.BoxAlign | undefined;
+            KhtmlBoxDirection?: Property.BoxDirection | undefined;
+            KhtmlBoxFlex?: Property.BoxFlex | undefined;
+            KhtmlBoxFlexGroup?: Property.BoxFlexGroup | undefined;
+            KhtmlBoxLines?: Property.BoxLines | undefined;
+            KhtmlBoxOrdinalGroup?: Property.BoxOrdinalGroup | undefined;
+            KhtmlBoxOrient?: Property.BoxOrient | undefined;
+            KhtmlBoxPack?: Property.BoxPack | undefined;
+            KhtmlLineBreak?: Property.LineBreak | undefined;
+            KhtmlOpacity?: Property.Opacity | undefined;
+            KhtmlUserSelect?: Property.UserSelect | undefined;
+            MozBackgroundClip?: Property.BackgroundClip | undefined;
+            MozBackgroundInlinePolicy?: Property.BoxDecorationBreak | undefined;
+            MozBackgroundOrigin?: Property.BackgroundOrigin | undefined;
+            MozBackgroundSize?: Property.BackgroundSize<string | number> | undefined;
+            MozBorderRadius?: Property.BorderRadius<string | number> | undefined;
+            MozBorderRadiusBottomleft?: Property.BorderBottomLeftRadius<string | number> | undefined;
+            MozBorderRadiusBottomright?: Property.BorderBottomRightRadius<string | number> | undefined;
+            MozBorderRadiusTopleft?: Property.BorderTopLeftRadius<string | number> | undefined;
+            MozBorderRadiusTopright?: Property.BorderTopRightRadius<string | number> | undefined;
+            MozBoxAlign?: Property.BoxAlign | undefined;
+            MozBoxDirection?: Property.BoxDirection | undefined;
+            MozBoxFlex?: Property.BoxFlex | undefined;
+            MozBoxOrdinalGroup?: Property.BoxOrdinalGroup | undefined;
+            MozBoxOrient?: Property.BoxOrient | undefined;
+            MozBoxPack?: Property.BoxPack | undefined;
+            MozBoxShadow?: Property.BoxShadow | undefined;
+            MozFloatEdge?: Property.MozFloatEdge | undefined;
+            MozForceBrokenImageIcon?: Property.MozForceBrokenImageIcon | undefined;
+            MozOpacity?: Property.Opacity | undefined;
+            MozOutline?: Property.Outline<string | number> | undefined;
+            MozOutlineColor?: Property.OutlineColor | undefined;
+            MozOutlineRadius?: Property.MozOutlineRadius<string | number> | undefined;
+            MozOutlineRadiusBottomleft?: Property.MozOutlineRadiusBottomleft<string | number> | undefined;
+            MozOutlineRadiusBottomright?: Property.MozOutlineRadiusBottomright<string | number> | undefined;
+            MozOutlineRadiusTopleft?: Property.MozOutlineRadiusTopleft<string | number> | undefined;
+            MozOutlineRadiusTopright?: Property.MozOutlineRadiusTopright<string | number> | undefined;
+            MozOutlineStyle?: Property.OutlineStyle | undefined;
+            MozOutlineWidth?: Property.OutlineWidth<string | number> | undefined;
+            MozTextAlignLast?: Property.TextAlignLast | undefined;
+            MozTextDecorationColor?: Property.TextDecorationColor | undefined;
+            MozTextDecorationLine?: Property.TextDecorationLine | undefined;
+            MozTextDecorationStyle?: Property.TextDecorationStyle | undefined;
+            MozUserInput?: Property.MozUserInput | undefined;
+            msImeMode?: Property.ImeMode | undefined;
+            OAnimation?: Property.Animation<string & {}> | undefined;
+            OAnimationDelay?: Property.AnimationDelay<string & {}> | undefined;
+            OAnimationDirection?: Property.AnimationDirection | undefined;
+            OAnimationDuration?: Property.AnimationDuration<string & {}> | undefined;
+            OAnimationFillMode?: Property.AnimationFillMode | undefined;
+            OAnimationIterationCount?: Property.AnimationIterationCount | undefined;
+            OAnimationName?: Property.AnimationName | undefined;
+            OAnimationPlayState?: Property.AnimationPlayState | undefined;
+            OAnimationTimingFunction?: Property.AnimationTimingFunction | undefined;
+            OBackgroundSize?: Property.BackgroundSize<string | number> | undefined;
+            OBorderImage?: Property.BorderImage | undefined;
+            OObjectFit?: Property.ObjectFit | undefined;
+            OObjectPosition?: Property.ObjectPosition<string | number> | undefined;
+            OTabSize?: Property.TabSize<string | number> | undefined;
+            OTextOverflow?: Property.TextOverflow | undefined;
+            OTransform?: Property.Transform | undefined;
+            OTransformOrigin?: Property.TransformOrigin<string | number> | undefined;
+            OTransition?: Property.Transition<string & {}> | undefined;
+            OTransitionDelay?: Property.TransitionDelay<string & {}> | undefined;
+            OTransitionDuration?: Property.TransitionDuration<string & {}> | undefined;
+            OTransitionProperty?: Property.TransitionProperty | undefined;
+            OTransitionTimingFunction?: Property.TransitionTimingFunction | undefined;
+            WebkitBoxAlign?: Property.BoxAlign | undefined;
+            WebkitBoxDirection?: Property.BoxDirection | undefined;
+            WebkitBoxFlex?: Property.BoxFlex | undefined;
+            WebkitBoxFlexGroup?: Property.BoxFlexGroup | undefined;
+            WebkitBoxLines?: Property.BoxLines | undefined;
+            WebkitBoxOrdinalGroup?: Property.BoxOrdinalGroup | undefined;
+            WebkitBoxOrient?: Property.BoxOrient | undefined;
+            WebkitBoxPack?: Property.BoxPack | undefined;
+            WebkitScrollSnapPointsX?: Property.ScrollSnapPointsX | undefined;
+            WebkitScrollSnapPointsY?: Property.ScrollSnapPointsY | undefined;
+            alignmentBaseline?: Property.AlignmentBaseline | undefined;
+            baselineShift?: Property.BaselineShift<string | number> | undefined;
+            clipRule?: Property.ClipRule | undefined;
+            colorInterpolation?: Property.ColorInterpolation | undefined;
+            colorRendering?: Property.ColorRendering | undefined;
+            dominantBaseline?: Property.DominantBaseline | undefined;
+            fill?: Property.Fill | undefined;
+            fillOpacity?: Property.FillOpacity | undefined;
+            fillRule?: Property.FillRule | undefined;
+            floodColor?: Property.FloodColor | undefined;
+            floodOpacity?: Property.FloodOpacity | undefined;
+            glyphOrientationVertical?: Property.GlyphOrientationVertical | undefined;
+            lightingColor?: Property.LightingColor | undefined;
+            marker?: Property.Marker | undefined;
+            markerEnd?: Property.MarkerEnd | undefined;
+            markerMid?: Property.MarkerMid | undefined;
+            markerStart?: Property.MarkerStart | undefined;
+            shapeRendering?: Property.ShapeRendering | undefined;
+            stopColor?: Property.StopColor | undefined;
+            stopOpacity?: Property.StopOpacity | undefined;
+            stroke?: Property.Stroke | undefined;
+            strokeDasharray?: Property.StrokeDasharray<string | number> | undefined;
+            strokeDashoffset?: Property.StrokeDashoffset<string | number> | undefined;
+            strokeLinecap?: Property.StrokeLinecap | undefined;
+            strokeLinejoin?: Property.StrokeLinejoin | undefined;
+            strokeMiterlimit?: Property.StrokeMiterlimit | undefined;
+            strokeOpacity?: Property.StrokeOpacity | undefined;
+            strokeWidth?: Property.StrokeWidth<string | number> | undefined;
+            textAnchor?: Property.TextAnchor | undefined;
+            vectorEffect?: Property.VectorEffect | undefined;
+        };
+        arrowPos: (Partial<Coords> & {
+            centerOffset: number;
+            alignmentOffset?: number;
+        }) | undefined;
+        arrowRef: RefObject<HTMLDivElement | null>;
+        arrowSide: string;
+    };
+};
+
+export declare type UseTooltipOptions = {
+    placement?: Placement | 'auto';
+};
 
 export { }