polpo 0.1.7 → 0.1.8

package/dist/components.d.ts

@@ -0,0 +1,1866 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as React$1 from 'react';
+import React__default, { ButtonHTMLAttributes, CSSProperties, DetailedHTMLProps, ImgHTMLAttributes, RefObject, ReactNode } from 'react';
+import { IconType } from 'react-icons';
+import { UseControllerProps } from 'react-hook-form';
+import { M as ModalState, a as UseModalTransitionParams, U as UseModalInContainerParams } from './use-modal-transition-C0lyjvkD.js';
+import { P as PositionContainer } from './get-modal-position-C5jQsaGx.js';
+import * as csstype from 'csstype';
+import { KeyValuesOf } from './types.js';
+
+declare const useAccordionItem: (id: string) => [boolean, () => void];
+type AccordionProps = {
+    children: React__default.ReactNode;
+    className?: string;
+    style?: React__default.CSSProperties;
+    noSeparators?: boolean;
+    multiple?: boolean;
+    defaultOpened?: Array<string> | string;
+};
+declare const Accordion: ({ children, className, noSeparators, multiple, style, defaultOpened, }: AccordionProps) => react_jsx_runtime.JSX.Element;
+
+type NodeFunction = (isOpen: boolean) => React__default.ReactNode;
+type ContentType = React__default.ReactNode | NodeFunction;
+type AccordionItemCommonProps = {
+    icon?: IconType;
+    children: React__default.ReactNode;
+    startContent?: ContentType;
+    endContent?: ContentType;
+    className?: string;
+    style?: React__default.CSSProperties;
+    classNames?: {
+        header?: string;
+        headerContent?: string;
+        title?: string;
+        subtitle?: string;
+        toggleIcon?: string;
+        body?: string;
+    };
+};
+type AccordionItemTitleProps = AccordionItemCommonProps & {
+    title?: ContentType;
+    subtitle?: ContentType;
+    content?: never;
+};
+type AccordionItemContentProps = AccordionItemCommonProps & {
+    title?: never;
+    subtitle?: never;
+    content?: ContentType;
+};
+type AccordionItemProps = AccordionItemTitleProps | AccordionItemContentProps;
+declare const AccordionItem: React__default.FC<AccordionItemProps>;
+
+declare enum ColorTypes {
+    DEFAULT = "default",
+    PRIMARY = "primary",
+    SECONDARY = "secondary",
+    TERTIARY = "tertiary",
+    ACTIVE = "active",
+    WARNING = "warning",
+    ALERT = "alert",
+    INFO = "info"
+}
+declare enum SizeTypes {
+    SMALL = "small",
+    REGULAR = "regular",
+    LARGE = "large"
+}
+declare enum VariantTypes {
+    SOLID = "solid",
+    FLAT = "flat",
+    OUTLINED = "outlined",
+    TEXT = "text"
+}
+declare enum RadiusTypes {
+    NONE = "none",
+    SMALL = "small",
+    MEDIUM = "medium",
+    LARGE = "large",
+    FULL = "full"
+}
+
+interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    children: React.ReactNode;
+    color?: `${ColorTypes}`;
+    variant?: `${VariantTypes}`;
+    radius?: `${RadiusTypes}`;
+    size?: `${SizeTypes}`;
+    noWrap?: boolean;
+    ref?: React.Ref<HTMLButtonElement>;
+    forIcon?: boolean;
+    isLoading?: boolean;
+}
+declare const Button: ({ children, color, variant, radius, size, noWrap, forIcon, className, ...props }: ButtonProps) => react_jsx_runtime.JSX.Element;
+
+type SlideCardProps = {
+    children: React__default.ReactNode;
+    isOpen: boolean;
+    className?: string;
+    style?: React__default.CSSProperties;
+};
+declare const SlideCard: ({ children, isOpen, className, style }: SlideCardProps) => react_jsx_runtime.JSX.Element;
+
+type FlipCardProps = {
+    cardZIndex?: CSSProperties['zIndex'];
+    isFlipped?: boolean;
+    flipSpeed?: number;
+    flipDirection?: 'horizontal' | 'vertical';
+    children: [React.ReactNode, React.ReactNode];
+};
+declare const FlipCard: ({ cardZIndex, flipDirection, flipSpeed, isFlipped, children, }: FlipCardProps) => react_jsx_runtime.JSX.Element;
+
+type HoverCardProps = {
+    children: React.ReactNode;
+    threshold?: number;
+    translationZ?: number;
+    width?: 'fit-content' | '100%';
+    className?: string;
+};
+declare const HoverCard: ({ children, threshold, translationZ, width, className, }: HoverCardProps) => react_jsx_runtime.JSX.Element;
+
+declare const Cursor: () => react_jsx_runtime.JSX.Element | null;
+
+type Props = {
+    [key: string]: unknown;
+};
+type SharedProps = {
+    name: string;
+    className?: string;
+    style?: React__default.CSSProperties;
+    autoComplete?: string;
+    autoFocus?: boolean;
+    placeholder?: string;
+    disabled?: boolean;
+    readOnly?: boolean;
+    onBlur?: (e: React__default.FocusEvent<unknown>) => void;
+    onFocus?: (e: React__default.FocusEvent<unknown>) => void;
+};
+type UnControlledProps<V> = {
+    value: V;
+    setValue: (value: V) => void;
+    invalid?: boolean;
+    isTouched?: boolean;
+    isDirty?: boolean;
+    error?: string;
+};
+type ControlledProps<V> = {
+    defaultValue?: V;
+};
+type UnControlledComponentProps<T extends Props, V> = T & SharedProps & UnControlledProps<V>;
+type ControlledComponentProps<T extends Props, V> = T & SharedProps & ControlledProps<V>;
+type ControllerGeneratorProps<T extends Props, V> = ControlledComponentProps<T, V> & Partial<Pick<UseControllerProps, 'rules'>>;
+
+type CheckboxProps = {
+    label?: React.ReactNode;
+    placeholder?: never;
+    icon?: IconType;
+    color?: `${ColorTypes}`;
+    size?: `${SizeTypes}`;
+};
+declare const Checkbox: {
+    ({ name, value, setValue, onBlur, onFocus, className, style, autoFocus, readOnly, disabled, autoComplete, icon: Icon, label, color, size, }: UnControlledComponentProps<CheckboxProps, boolean>): react_jsx_runtime.JSX.Element;
+    Controller: ({ rules, ...props }: ControllerGeneratorProps<CheckboxProps, boolean>) => react_jsx_runtime.JSX.Element;
+};
+
+declare enum FieldVariant {
+    FULL_BORDER = "full-border",
+    CONTENT_BORDER = "content-border",
+    CONTENT_LINE = "line"
+}
+declare enum FieldOrientation {
+    HORIZONTAL = "horizontal",
+    VERTICAL = "vertical"
+}
+type FieldSharedProps = {
+    rightIcon?: IconType;
+    leftIcon?: IconType;
+    errorIcon?: IconType;
+    onClickLeftIcon?: () => void;
+    onClickRightIcon?: () => void;
+    label?: string;
+    variant?: `${FieldVariant}`;
+    ref?: React__default.RefObject<HTMLElement | null>;
+};
+type FieldProps = FieldSharedProps & {
+    children: React__default.ReactNode;
+    id: string;
+    error?: string;
+    isFocus?: boolean;
+    fieldOrientation?: `${FieldOrientation}`;
+};
+type InputFieldProps<T> = T & FieldSharedProps;
+
+declare const Field: ({ id, label, leftIcon, rightIcon, errorIcon: ErrorIcon, error, onClickLeftIcon, onClickRightIcon, fieldOrientation, children, isFocus, variant, ref, }: FieldProps) => react_jsx_runtime.JSX.Element;
+
+type DatePickerProps = InputFieldProps<{
+    type?: 'date' | 'datetime-local' | 'month' | 'time' | 'week';
+}>;
+declare const DatePicker: {
+    ({ name, value, setValue, onBlur, onFocus, type, className, style, autoFocus, readOnly, disabled, placeholder, autoComplete, isDirty, isTouched, invalid, error, ...fieldProps }: UnControlledComponentProps<DatePickerProps, string>): react_jsx_runtime.JSX.Element;
+    Controller: ({ rules, ...props }: ControllerGeneratorProps<DatePickerProps, string>) => react_jsx_runtime.JSX.Element;
+};
+
+type IProps$1 = InputFieldProps<{
+    pattern?: string;
+    type?: 'email' | 'search' | 'text' | 'url';
+    min?: number;
+    max?: number;
+}>;
+declare const Input: {
+    ({ name, value, setValue, onBlur, onFocus, pattern, type, className, style, autoFocus, readOnly, disabled, placeholder, autoComplete, isDirty, isTouched, invalid, error, min, max, ...fieldProps }: UnControlledComponentProps<IProps$1, string>): react_jsx_runtime.JSX.Element;
+    Controller: ({ rules, ...props }: ControllerGeneratorProps<IProps$1, string>) => react_jsx_runtime.JSX.Element;
+};
+
+type InputPasswordProps = InputFieldProps<{
+    rightIcon?: never;
+}>;
+declare const InputPassword: {
+    ({ name, value, setValue, onBlur, onFocus, className, style, autoFocus, readOnly, disabled, placeholder, autoComplete, isDirty, isTouched, invalid, error, ...fieldProps }: UnControlledComponentProps<InputPasswordProps, string>): react_jsx_runtime.JSX.Element;
+    Controller: ({ rules, ...props }: ControllerGeneratorProps<InputPasswordProps, string>) => react_jsx_runtime.JSX.Element;
+};
+
+type ColorProps = InputFieldProps<{
+    showValueText?: boolean;
+}>;
+declare const InputColor: {
+    ({ name, value, setValue, onBlur, onFocus, showValueText, className, style, autoFocus, readOnly, disabled, placeholder, autoComplete, isDirty, isTouched, invalid, error, ...fieldProps }: UnControlledComponentProps<ColorProps, string>): react_jsx_runtime.JSX.Element;
+    Controller: ({ rules, ...props }: ControllerGeneratorProps<ColorProps, string>) => react_jsx_runtime.JSX.Element;
+};
+
+type InputFileProps = {
+    label?: string;
+    accept?: string;
+    multiple?: boolean;
+    limitSize?: number;
+    errorTimeout?: number;
+};
+type InputFileValue = {
+    [key: string]: File;
+};
+declare const InputFile: {
+    ({ name, value, setValue, onBlur, onFocus, className, style, autoFocus, readOnly, disabled, placeholder, autoComplete, accept, multiple, limitSize, errorTimeout, label, }: UnControlledComponentProps<InputFileProps, InputFileValue>): react_jsx_runtime.JSX.Element;
+    Controller: ({ rules, ...props }: ControllerGeneratorProps<InputFileProps, InputFileValue>) => react_jsx_runtime.JSX.Element;
+};
+
+type FormatFunction = (value: number) => string;
+type FormatConfig = Intl.NumberFormatOptions & {
+    locales: Intl.LocalesArgument;
+};
+type IProps = InputFieldProps<{
+    pattern?: string;
+    min?: number;
+    max?: number;
+    format?: FormatConfig | FormatFunction;
+    decimalSeparator?: string;
+}>;
+declare const InputNumber: {
+    ({ name, value, setValue, onBlur, onFocus, pattern, className, style, autoFocus, readOnly, disabled, placeholder, autoComplete, isDirty, isTouched, invalid, error, min, max, decimalSeparator, format, ...fieldProps }: UnControlledComponentProps<IProps, number>): react_jsx_runtime.JSX.Element;
+    Controller: ({ rules, ...props }: ControllerGeneratorProps<IProps, number>) => react_jsx_runtime.JSX.Element;
+};
+
+type RadioProps = {
+    label?: string;
+    radioValue: string;
+    placeholder?: never;
+    color?: `${ColorTypes}`;
+    size?: `${SizeTypes}`;
+};
+declare const Radio: {
+    ({ name, value, setValue, onBlur, onFocus, className, style, autoFocus, readOnly, disabled, autoComplete, radioValue, label, color, size, }: UnControlledComponentProps<RadioProps, string>): react_jsx_runtime.JSX.Element;
+    Controller: ({ rules, ...props }: ControllerGeneratorProps<RadioProps, string>) => react_jsx_runtime.JSX.Element;
+};
+
+type SelectItem = string | number | Record<string, unknown> | unknown;
+type MultiValue<T extends SelectItem> = Array<T>;
+type SingleValue<T extends SelectItem> = T | null;
+type OptionComponentProps<T extends SelectItem> = {
+    value: T;
+};
+type ValueComponentProps<T extends SelectItem> = {
+    value: MultiValue<T>;
+    multiselect: true;
+} | {
+    value: SingleValue<T>;
+    multiselect?: false;
+};
+type SharedSelectProps<T extends SelectItem> = InputFieldProps<{
+    options: Array<T>;
+    isEqualComparator?: (a: T, b: T) => boolean;
+    searchQueryValue?: string;
+    searchQueryPlaceholder?: string;
+    onSearchQuery?: (value: string) => void;
+    loadMore?: () => void;
+    isLoading?: boolean;
+    hasNextPage?: boolean;
+    emptyMessage?: string;
+    maxOptions?: number;
+    optionComponent?: React__default.FC<OptionComponentProps<T>>;
+    valueComponent?: React__default.FC<ValueComponentProps<T>>;
+    showClearOption?: boolean;
+    height?: number;
+    searchQueryClassName?: string;
+    searchQueryStyle?: React__default.CSSProperties;
+    children?: React__default.ReactNode;
+}>;
+type MultiSelectProps<T extends SelectItem> = SharedSelectProps<T> & {
+    multiselect: true;
+};
+type SingleSelectProps<T extends SelectItem> = SharedSelectProps<T> & {
+    multiselect?: false;
+};
+type UnControlledSelectProps<T extends SelectItem> = UnControlledComponentProps<MultiSelectProps<T>, MultiValue<T>> | UnControlledComponentProps<SingleSelectProps<T>, SingleValue<T>>;
+type ControllerGeneratorSelectProps<T extends SelectItem> = ControllerGeneratorProps<MultiSelectProps<T>, MultiValue<T>> | ControllerGeneratorProps<SingleSelectProps<T>, SingleValue<T>>;
+
+type OptionLabelProps = {
+    children: React__default.ReactNode;
+};
+declare const Select: {
+    <T extends SelectItem>({ options, isEqualComparator, searchQueryValue, searchQueryPlaceholder, onSearchQuery, loadMore, isLoading, hasNextPage, emptyMessage, multiselect, optionComponent: OptionComponent, valueComponent: ValueComponent, maxOptions, children, name, value, setValue, onBlur, onFocus, className, style, showClearOption, height, searchQueryStyle, searchQueryClassName, autoFocus, readOnly, disabled, placeholder, autoComplete, isDirty, isTouched, invalid, error, ...fieldProps }: UnControlledSelectProps<T>): react_jsx_runtime.JSX.Element;
+    Controller: <T extends SelectItem>(props: ControllerGeneratorSelectProps<T>) => react_jsx_runtime.JSX.Element;
+    Option: <T extends SelectItem>({ children, value }: {
+        children: React__default.ReactNode;
+        value: T;
+    }) => react_jsx_runtime.JSX.Element;
+    OptionLabel: ({ children }: OptionLabelProps) => react_jsx_runtime.JSX.Element;
+};
+
+type SliderProps = InputFieldProps<{
+    min?: number;
+    max?: number;
+    step?: number;
+    onlySlider?: boolean;
+}>;
+declare const Slider: {
+    ({ name, value, setValue, onBlur, onFocus, min, max, step, onlySlider, className, style, autoFocus, readOnly, disabled, placeholder, autoComplete, isDirty, isTouched, invalid, error, ...fieldProps }: UnControlledComponentProps<SliderProps, number>): react_jsx_runtime.JSX.Element;
+    Controller: ({ rules, ...props }: ControllerGeneratorProps<SliderProps, number>) => react_jsx_runtime.JSX.Element;
+};
+
+type TextareaProps = InputFieldProps<{
+    rows?: number;
+    resize?: React__default.CSSProperties['resize'];
+    leftIcon?: never;
+    rightIcon?: never;
+}>;
+declare const Textarea: {
+    ({ name, value, setValue, onBlur, onFocus, rows, resize, className, style, autoFocus, readOnly, disabled, placeholder, autoComplete, isDirty, isTouched, invalid, error, ...fieldProps }: UnControlledComponentProps<TextareaProps, string>): react_jsx_runtime.JSX.Element;
+    Controller: ({ rules, ...props }: ControllerGeneratorProps<TextareaProps, string>) => react_jsx_runtime.JSX.Element;
+};
+
+type SwitchProps = {
+    leftLabel?: string;
+    rightLabel?: string;
+    label?: string;
+    dotHoverSize?: number;
+    padding?: number;
+    leftIcon?: IconType;
+    rightIcon?: IconType;
+    internalLeftIcon?: IconType;
+    internalRightIcon?: IconType;
+    leftIconTooltip?: string;
+    rightIconTooltip?: string;
+    color?: `${ColorTypes}`;
+    size?: `${SizeTypes}`;
+    width?: `${SizeTypes}`;
+};
+declare const Switch: {
+    ({ name, value, setValue, onBlur, onFocus, className, style, autoFocus, readOnly, disabled, placeholder, autoComplete, label, leftLabel, rightLabel, width, size, dotHoverSize, padding, leftIcon: LeftIcon, rightIcon: RightIcon, internalLeftIcon: InternalLeftIcon, internalRightIcon: InternalRightIcon, leftIconTooltip, rightIconTooltip, color, }: UnControlledComponentProps<SwitchProps, boolean>): react_jsx_runtime.JSX.Element;
+    Controller: ({ rules, ...props }: ControllerGeneratorProps<SwitchProps, boolean>) => react_jsx_runtime.JSX.Element;
+};
+
+type ImageProps = DetailedHTMLProps<ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement> & {};
+declare const Image: ({ alt, loading, ...props }: ImageProps) => react_jsx_runtime.JSX.Element;
+
+interface InfinityScrollProps extends React.HTMLAttributes<HTMLDivElement> {
+    isLoading: boolean;
+    hasNextPage: boolean;
+    loadMore: () => void;
+    customLoadMoreElement?: (ref: React.RefObject<HTMLElement | null>) => React.ReactNode;
+    emptyMessage?: string;
+    children?: React.ReactNode;
+}
+declare const InfinityScroll: ({ isLoading: isLoadingProp, hasNextPage, loadMore, customLoadMoreElement, emptyMessage, children, }: InfinityScrollProps) => react_jsx_runtime.JSX.Element;
+
+declare enum LineOrientation {
+    VERTICAL = "vertical",
+    HORIZONTAL = "horizontal"
+}
+declare enum LineStyle {
+    SOLID = "solid",
+    DOTTED = "dotted",
+    DASHED = "dashed"
+}
+type LineCommonProps = {
+    orientation?: `${LineOrientation}`;
+    className?: string;
+    style?: React.CSSProperties;
+    color?: string;
+};
+type LineSolidProps = LineCommonProps & {
+    lineStyle?: `${LineStyle.SOLID}`;
+    spacing?: never;
+    dashedSize?: never;
+    size?: number;
+};
+type LineDottedProps = LineCommonProps & {
+    lineStyle: `${LineStyle.DOTTED}`;
+    spacing?: number;
+    size?: number;
+    dashedSize?: never;
+};
+type LineDashedProps = LineCommonProps & {
+    lineStyle: `${LineStyle.DASHED}`;
+    spacing?: number;
+    dashedSize?: number;
+    size?: number;
+};
+type LineProps = LineSolidProps | LineDottedProps | LineDashedProps;
+declare const Line: ({ orientation, className, style, color, size, lineStyle, dashedSize, spacing, }: LineProps) => react_jsx_runtime.JSX.Element;
+
+declare enum ModalBackdrop {
+    OPAQUE = "opaque",
+    TRANSPARENT = "transparent",
+    BLUR = "blur",
+    NONE = "none"
+}
+type BackdropProps = {
+    opacity?: number;
+    backdrop?: `${ModalBackdrop}`;
+    zIndex?: React__default.CSSProperties['zIndex'];
+    backdropOnClick?: () => void;
+    modalState?: ModalState;
+};
+declare const Backdrop: ({ opacity, backdrop, zIndex, backdropOnClick, modalState, }: BackdropProps) => react_jsx_runtime.JSX.Element | null;
+
+type ModalProps = Omit<BackdropProps, 'modalState'> & UseModalTransitionParams & Omit<UseModalInContainerParams, 'modalRef'> & {
+    id: string;
+    children: React__default.ReactNode;
+    onClose: () => void;
+    className?: string;
+    style?: React__default.CSSProperties;
+    rootStyle?: CSSProperties;
+    animation?: 'none' | 'fade-down' | 'bounce';
+    closeAnimationClassName?: string;
+    modalRef?: React__default.RefObject<HTMLElement | null>;
+    closeOnClickOutside?: boolean;
+};
+declare const Modal: ({ id, children, isOpen, onClose, className, style, rootStyle, animation, closeAnimationClassName, modalRef: modalRefProp, closeOnClickOutside, transitionDuration, windowOffset, offset, position, containerRef, zIndex, ...backdropProps }: ModalProps) => react_jsx_runtime.JSX.Element | null;
+
+type ActionModalProps = Omit<ModalProps, 'id' | 'animation' | 'closeAnimationClassName' | 'position' | 'rootStyle' | 'className' | 'style'> & {
+    actionRequired?: boolean;
+    icon?: IconType;
+    noCloseButton?: boolean;
+    lineOnTop?: boolean;
+    backCard?: boolean;
+    noPadding?: boolean;
+    className?: string;
+    style?: React.CSSProperties;
+};
+declare const ActionModal: {
+    ({ children, isOpen, onClose, actionRequired, icon: Icon, noCloseButton, lineOnTop, backCard, noPadding, className, style, ...modalProps }: ActionModalProps): react_jsx_runtime.JSX.Element;
+    ActionButton: ({ onClick, children, isLoading: manualIsLoading, ...buttonProps }: ActionButtonProps) => react_jsx_runtime.JSX.Element | null;
+};
+type ActionButtonProps = Omit<ButtonProps, 'onClick'> & {
+    onClick: (() => Promise<void>) | (() => void);
+};
+
+type AsideModalProps = Omit<ModalProps, 'id' | 'animation' | 'closeAnimationClassName' | 'position' | 'rootStyle' | 'className' | 'style'> & {
+    position?: `${PositionContainer.TOP}` | `${PositionContainer.LEFT}` | `${PositionContainer.RIGHT}` | `${PositionContainer.BOTTOM}`;
+    size?: number | `${number}px` | `${number}em`;
+    className?: string;
+    style?: React.CSSProperties;
+};
+declare const AsideModal: ({ children, isOpen, onClose, position, size, className, ...modalProps }: AsideModalProps) => react_jsx_runtime.JSX.Element;
+
+type ConfirmationModalProps = ActionModalProps & {
+    title: string;
+    onAccept: (() => Promise<void>) | (() => void);
+    onReject?: (() => Promise<void>) | (() => void);
+    acceptText: string;
+    rejectText: string;
+    isLoading?: boolean;
+};
+declare const ConfirmationModal: ({ title, onAccept, onReject, acceptText, rejectText, children, isLoading, ...actionModalProps }: ConfirmationModalProps) => react_jsx_runtime.JSX.Element;
+
+declare enum TypographyColors {
+    PRIMARY = "primary",
+    SECONDARY = "secondary",
+    TERTIARY = "tertiary",
+    ACTIVE = "active",
+    WARNING = "warning",
+    ALERT = "alert",
+    INFO = "info"
+}
+declare enum TypographyVariant {
+    HERO = "hero",
+    HEADER1 = "header1",
+    HEADER2 = "header2",
+    HEADER3 = "header3",
+    HEADER4 = "header4",
+    BODY = "body",
+    LABEL = "label",
+    LABEL_FORM = "label-form",
+    SMALL = "small"
+}
+declare enum TypographyWeight {
+    LIGHT = "light",
+    REGULAR = "regular",
+    BOLD = "bold"
+}
+
+type TypographyProps = React__default.HTMLAttributes<HTMLElement | HTMLLabelElement> & {
+    variant?: `${TypographyVariant}`;
+    nowrap?: boolean | number;
+    as?: React__default.HTMLElementType;
+    weight?: `${TypographyWeight}`;
+    children: React__default.ReactNode;
+    noPadding?: boolean;
+    htmlFor?: string;
+    align?: React__default.CSSProperties['textAlign'];
+    family?: 'primary' | 'code';
+    recommendedWidth?: boolean;
+    color?: `${TypographyColors}`;
+    ref?: React__default.RefObject<HTMLElement>;
+    style?: React__default.CSSProperties;
+};
+declare const Typography: ({ variant, nowrap, className: customClassname, style, children, as, weight, family, noPadding, align, color, htmlFor, recommendedWidth, ...props }: TypographyProps) => React__default.DetailedReactHTMLElement<{
+    className: string;
+    htmlFor: string | undefined;
+    style: {
+        accentColor?: csstype.Property.AccentColor | undefined;
+        alignContent?: csstype.Property.AlignContent | undefined;
+        alignItems?: csstype.Property.AlignItems | undefined;
+        alignSelf?: csstype.Property.AlignSelf | undefined;
+        alignTracks?: csstype.Property.AlignTracks | undefined;
+        alignmentBaseline?: csstype.Property.AlignmentBaseline | undefined;
+        anchorName?: csstype.Property.AnchorName | undefined;
+        anchorScope?: csstype.Property.AnchorScope | undefined;
+        animationComposition?: csstype.Property.AnimationComposition | undefined;
+        animationDelay?: csstype.Property.AnimationDelay<string & {}> | undefined;
+        animationDirection?: csstype.Property.AnimationDirection | undefined;
+        animationDuration?: csstype.Property.AnimationDuration<string & {}> | undefined;
+        animationFillMode?: csstype.Property.AnimationFillMode | undefined;
+        animationIterationCount?: csstype.Property.AnimationIterationCount | undefined;
+        animationName?: csstype.Property.AnimationName | undefined;
+        animationPlayState?: csstype.Property.AnimationPlayState | undefined;
+        animationRangeEnd?: csstype.Property.AnimationRangeEnd<string | number> | undefined;
+        animationRangeStart?: csstype.Property.AnimationRangeStart<string | number> | undefined;
+        animationTimeline?: csstype.Property.AnimationTimeline | undefined;
+        animationTimingFunction?: csstype.Property.AnimationTimingFunction | undefined;
+        appearance?: csstype.Property.Appearance | undefined;
+        aspectRatio?: csstype.Property.AspectRatio | undefined;
+        backdropFilter?: csstype.Property.BackdropFilter | undefined;
+        backfaceVisibility?: csstype.Property.BackfaceVisibility | undefined;
+        backgroundAttachment?: csstype.Property.BackgroundAttachment | undefined;
+        backgroundBlendMode?: csstype.Property.BackgroundBlendMode | undefined;
+        backgroundClip?: csstype.Property.BackgroundClip | undefined;
+        backgroundColor?: csstype.Property.BackgroundColor | undefined;
+        backgroundImage?: csstype.Property.BackgroundImage | undefined;
+        backgroundOrigin?: csstype.Property.BackgroundOrigin | undefined;
+        backgroundPositionX?: csstype.Property.BackgroundPositionX<string | number> | undefined;
+        backgroundPositionY?: csstype.Property.BackgroundPositionY<string | number> | undefined;
+        backgroundRepeat?: csstype.Property.BackgroundRepeat | undefined;
+        backgroundSize?: csstype.Property.BackgroundSize<string | number> | undefined;
+        baselineShift?: csstype.Property.BaselineShift<string | number> | undefined;
+        blockSize?: csstype.Property.BlockSize<string | number> | undefined;
+        borderBlockEndColor?: csstype.Property.BorderBlockEndColor | undefined;
+        borderBlockEndStyle?: csstype.Property.BorderBlockEndStyle | undefined;
+        borderBlockEndWidth?: csstype.Property.BorderBlockEndWidth<string | number> | undefined;
+        borderBlockStartColor?: csstype.Property.BorderBlockStartColor | undefined;
+        borderBlockStartStyle?: csstype.Property.BorderBlockStartStyle | undefined;
+        borderBlockStartWidth?: csstype.Property.BorderBlockStartWidth<string | number> | undefined;
+        borderBottomColor?: csstype.Property.BorderBottomColor | undefined;
+        borderBottomLeftRadius?: csstype.Property.BorderBottomLeftRadius<string | number> | undefined;
+        borderBottomRightRadius?: csstype.Property.BorderBottomRightRadius<string | number> | undefined;
+        borderBottomStyle?: csstype.Property.BorderBottomStyle | undefined;
+        borderBottomWidth?: csstype.Property.BorderBottomWidth<string | number> | undefined;
+        borderCollapse?: csstype.Property.BorderCollapse | undefined;
+        borderEndEndRadius?: csstype.Property.BorderEndEndRadius<string | number> | undefined;
+        borderEndStartRadius?: csstype.Property.BorderEndStartRadius<string | number> | undefined;
+        borderImageOutset?: csstype.Property.BorderImageOutset<string | number> | undefined;
+        borderImageRepeat?: csstype.Property.BorderImageRepeat | undefined;
+        borderImageSlice?: csstype.Property.BorderImageSlice | undefined;
+        borderImageSource?: csstype.Property.BorderImageSource | undefined;
+        borderImageWidth?: csstype.Property.BorderImageWidth<string | number> | undefined;
+        borderInlineEndColor?: csstype.Property.BorderInlineEndColor | undefined;
+        borderInlineEndStyle?: csstype.Property.BorderInlineEndStyle | undefined;
+        borderInlineEndWidth?: csstype.Property.BorderInlineEndWidth<string | number> | undefined;
+        borderInlineStartColor?: csstype.Property.BorderInlineStartColor | undefined;
+        borderInlineStartStyle?: csstype.Property.BorderInlineStartStyle | undefined;
+        borderInlineStartWidth?: csstype.Property.BorderInlineStartWidth<string | number> | undefined;
+        borderLeftColor?: csstype.Property.BorderLeftColor | undefined;
+        borderLeftStyle?: csstype.Property.BorderLeftStyle | undefined;
+        borderLeftWidth?: csstype.Property.BorderLeftWidth<string | number> | undefined;
+        borderRightColor?: csstype.Property.BorderRightColor | undefined;
+        borderRightStyle?: csstype.Property.BorderRightStyle | undefined;
+        borderRightWidth?: csstype.Property.BorderRightWidth<string | number> | undefined;
+        borderSpacing?: csstype.Property.BorderSpacing<string | number> | undefined;
+        borderStartEndRadius?: csstype.Property.BorderStartEndRadius<string | number> | undefined;
+        borderStartStartRadius?: csstype.Property.BorderStartStartRadius<string | number> | undefined;
+        borderTopColor?: csstype.Property.BorderTopColor | undefined;
+        borderTopLeftRadius?: csstype.Property.BorderTopLeftRadius<string | number> | undefined;
+        borderTopRightRadius?: csstype.Property.BorderTopRightRadius<string | number> | undefined;
+        borderTopStyle?: csstype.Property.BorderTopStyle | undefined;
+        borderTopWidth?: csstype.Property.BorderTopWidth<string | number> | undefined;
+        bottom?: csstype.Property.Bottom<string | number> | undefined;
+        boxDecorationBreak?: csstype.Property.BoxDecorationBreak | undefined;
+        boxShadow?: csstype.Property.BoxShadow | undefined;
+        boxSizing?: csstype.Property.BoxSizing | undefined;
+        breakAfter?: csstype.Property.BreakAfter | undefined;
+        breakBefore?: csstype.Property.BreakBefore | undefined;
+        breakInside?: csstype.Property.BreakInside | undefined;
+        captionSide?: csstype.Property.CaptionSide | undefined;
+        caretColor?: csstype.Property.CaretColor | undefined;
+        caretShape?: csstype.Property.CaretShape | undefined;
+        clear?: csstype.Property.Clear | undefined;
+        clipPath?: csstype.Property.ClipPath | undefined;
+        clipRule?: csstype.Property.ClipRule | undefined;
+        color?: csstype.Property.Color | undefined;
+        colorAdjust?: csstype.Property.PrintColorAdjust | undefined;
+        colorInterpolationFilters?: csstype.Property.ColorInterpolationFilters | undefined;
+        colorScheme?: csstype.Property.ColorScheme | undefined;
+        columnCount?: csstype.Property.ColumnCount | undefined;
+        columnFill?: csstype.Property.ColumnFill | undefined;
+        columnGap?: csstype.Property.ColumnGap<string | number> | undefined;
+        columnRuleColor?: csstype.Property.ColumnRuleColor | undefined;
+        columnRuleStyle?: csstype.Property.ColumnRuleStyle | undefined;
+        columnRuleWidth?: csstype.Property.ColumnRuleWidth<string | number> | undefined;
+        columnSpan?: csstype.Property.ColumnSpan | undefined;
+        columnWidth?: csstype.Property.ColumnWidth<string | number> | undefined;
+        contain?: csstype.Property.Contain | undefined;
+        containIntrinsicBlockSize?: csstype.Property.ContainIntrinsicBlockSize<string | number> | undefined;
+        containIntrinsicHeight?: csstype.Property.ContainIntrinsicHeight<string | number> | undefined;
+        containIntrinsicInlineSize?: csstype.Property.ContainIntrinsicInlineSize<string | number> | undefined;
+        containIntrinsicWidth?: csstype.Property.ContainIntrinsicWidth<string | number> | undefined;
+        containerName?: csstype.Property.ContainerName | undefined;
+        containerType?: csstype.Property.ContainerType | undefined;
+        content?: csstype.Property.Content | undefined;
+        contentVisibility?: csstype.Property.ContentVisibility | undefined;
+        counterIncrement?: csstype.Property.CounterIncrement | undefined;
+        counterReset?: csstype.Property.CounterReset | undefined;
+        counterSet?: csstype.Property.CounterSet | undefined;
+        cursor?: csstype.Property.Cursor | undefined;
+        cx?: csstype.Property.Cx<string | number> | undefined;
+        cy?: csstype.Property.Cy<string | number> | undefined;
+        d?: csstype.Property.D | undefined;
+        direction?: csstype.Property.Direction | undefined;
+        display?: csstype.Property.Display | undefined;
+        dominantBaseline?: csstype.Property.DominantBaseline | undefined;
+        emptyCells?: csstype.Property.EmptyCells | undefined;
+        fieldSizing?: csstype.Property.FieldSizing | undefined;
+        fill?: csstype.Property.Fill | undefined;
+        fillOpacity?: csstype.Property.FillOpacity | undefined;
+        fillRule?: csstype.Property.FillRule | undefined;
+        filter?: csstype.Property.Filter | undefined;
+        flexBasis?: csstype.Property.FlexBasis<string | number> | undefined;
+        flexDirection?: csstype.Property.FlexDirection | undefined;
+        flexGrow?: csstype.Property.FlexGrow | undefined;
+        flexShrink?: csstype.Property.FlexShrink | undefined;
+        flexWrap?: csstype.Property.FlexWrap | undefined;
+        float?: csstype.Property.Float | undefined;
+        floodColor?: csstype.Property.FloodColor | undefined;
+        floodOpacity?: csstype.Property.FloodOpacity | undefined;
+        fontFamily?: csstype.Property.FontFamily | undefined;
+        fontFeatureSettings?: csstype.Property.FontFeatureSettings | undefined;
+        fontKerning?: csstype.Property.FontKerning | undefined;
+        fontLanguageOverride?: csstype.Property.FontLanguageOverride | undefined;
+        fontOpticalSizing?: csstype.Property.FontOpticalSizing | undefined;
+        fontPalette?: csstype.Property.FontPalette | undefined;
+        fontSize?: csstype.Property.FontSize<string | number> | undefined;
+        fontSizeAdjust?: csstype.Property.FontSizeAdjust | undefined;
+        fontSmooth?: csstype.Property.FontSmooth<string | number> | undefined;
+        fontStyle?: csstype.Property.FontStyle | undefined;
+        fontSynthesis?: csstype.Property.FontSynthesis | undefined;
+        fontSynthesisPosition?: csstype.Property.FontSynthesisPosition | undefined;
+        fontSynthesisSmallCaps?: csstype.Property.FontSynthesisSmallCaps | undefined;
+        fontSynthesisStyle?: csstype.Property.FontSynthesisStyle | undefined;
+        fontSynthesisWeight?: csstype.Property.FontSynthesisWeight | undefined;
+        fontVariant?: csstype.Property.FontVariant | undefined;
+        fontVariantAlternates?: csstype.Property.FontVariantAlternates | undefined;
+        fontVariantCaps?: csstype.Property.FontVariantCaps | undefined;
+        fontVariantEastAsian?: csstype.Property.FontVariantEastAsian | undefined;
+        fontVariantEmoji?: csstype.Property.FontVariantEmoji | undefined;
+        fontVariantLigatures?: csstype.Property.FontVariantLigatures | undefined;
+        fontVariantNumeric?: csstype.Property.FontVariantNumeric | undefined;
+        fontVariantPosition?: csstype.Property.FontVariantPosition | undefined;
+        fontVariationSettings?: csstype.Property.FontVariationSettings | undefined;
+        fontWeight?: csstype.Property.FontWeight | undefined;
+        fontWidth?: csstype.Property.FontWidth | undefined;
+        forcedColorAdjust?: csstype.Property.ForcedColorAdjust | undefined;
+        gridAutoColumns?: csstype.Property.GridAutoColumns<string | number> | undefined;
+        gridAutoFlow?: csstype.Property.GridAutoFlow | undefined;
+        gridAutoRows?: csstype.Property.GridAutoRows<string | number> | undefined;
+        gridColumnEnd?: csstype.Property.GridColumnEnd | undefined;
+        gridColumnStart?: csstype.Property.GridColumnStart | undefined;
+        gridRowEnd?: csstype.Property.GridRowEnd | undefined;
+        gridRowStart?: csstype.Property.GridRowStart | undefined;
+        gridTemplateAreas?: csstype.Property.GridTemplateAreas | undefined;
+        gridTemplateColumns?: csstype.Property.GridTemplateColumns<string | number> | undefined;
+        gridTemplateRows?: csstype.Property.GridTemplateRows<string | number> | undefined;
+        hangingPunctuation?: csstype.Property.HangingPunctuation | undefined;
+        height?: csstype.Property.Height<string | number> | undefined;
+        hyphenateCharacter?: csstype.Property.HyphenateCharacter | undefined;
+        hyphenateLimitChars?: csstype.Property.HyphenateLimitChars | undefined;
+        hyphens?: csstype.Property.Hyphens | undefined;
+        imageOrientation?: csstype.Property.ImageOrientation | undefined;
+        imageRendering?: csstype.Property.ImageRendering | undefined;
+        imageResolution?: csstype.Property.ImageResolution | undefined;
+        initialLetter?: csstype.Property.InitialLetter | undefined;
+        initialLetterAlign?: csstype.Property.InitialLetterAlign | undefined;
+        inlineSize?: csstype.Property.InlineSize<string | number> | undefined;
+        insetBlockEnd?: csstype.Property.InsetBlockEnd<string | number> | undefined;
+        insetBlockStart?: csstype.Property.InsetBlockStart<string | number> | undefined;
+        insetInlineEnd?: csstype.Property.InsetInlineEnd<string | number> | undefined;
+        insetInlineStart?: csstype.Property.InsetInlineStart<string | number> | undefined;
+        interpolateSize?: csstype.Property.InterpolateSize | undefined;
+        isolation?: csstype.Property.Isolation | undefined;
+        justifyContent?: csstype.Property.JustifyContent | undefined;
+        justifyItems?: csstype.Property.JustifyItems | undefined;
+        justifySelf?: csstype.Property.JustifySelf | undefined;
+        justifyTracks?: csstype.Property.JustifyTracks | undefined;
+        left?: csstype.Property.Left<string | number> | undefined;
+        letterSpacing?: csstype.Property.LetterSpacing<string | number> | undefined;
+        lightingColor?: csstype.Property.LightingColor | undefined;
+        lineBreak?: csstype.Property.LineBreak | undefined;
+        lineHeight?: csstype.Property.LineHeight<string | number> | undefined;
+        lineHeightStep?: csstype.Property.LineHeightStep<string | number> | undefined;
+        listStyleImage?: csstype.Property.ListStyleImage | undefined;
+        listStylePosition?: csstype.Property.ListStylePosition | undefined;
+        listStyleType?: csstype.Property.ListStyleType | undefined;
+        marginBlockEnd?: csstype.Property.MarginBlockEnd<string | number> | undefined;
+        marginBlockStart?: csstype.Property.MarginBlockStart<string | number> | undefined;
+        marginBottom?: csstype.Property.MarginBottom<string | number> | undefined;
+        marginInlineEnd?: csstype.Property.MarginInlineEnd<string | number> | undefined;
+        marginInlineStart?: csstype.Property.MarginInlineStart<string | number> | undefined;
+        marginLeft?: csstype.Property.MarginLeft<string | number> | undefined;
+        marginRight?: csstype.Property.MarginRight<string | number> | undefined;
+        marginTop?: csstype.Property.MarginTop<string | number> | undefined;
+        marginTrim?: csstype.Property.MarginTrim | undefined;
+        marker?: csstype.Property.Marker | undefined;
+        markerEnd?: csstype.Property.MarkerEnd | undefined;
+        markerMid?: csstype.Property.MarkerMid | undefined;
+        markerStart?: csstype.Property.MarkerStart | undefined;
+        maskBorderMode?: csstype.Property.MaskBorderMode | undefined;
+        maskBorderOutset?: csstype.Property.MaskBorderOutset<string | number> | undefined;
+        maskBorderRepeat?: csstype.Property.MaskBorderRepeat | undefined;
+        maskBorderSlice?: csstype.Property.MaskBorderSlice | undefined;
+        maskBorderSource?: csstype.Property.MaskBorderSource | undefined;
+        maskBorderWidth?: csstype.Property.MaskBorderWidth<string | number> | undefined;
+        maskClip?: csstype.Property.MaskClip | undefined;
+        maskComposite?: csstype.Property.MaskComposite | undefined;
+        maskImage?: csstype.Property.MaskImage | undefined;
+        maskMode?: csstype.Property.MaskMode | undefined;
+        maskOrigin?: csstype.Property.MaskOrigin | undefined;
+        maskPosition?: csstype.Property.MaskPosition<string | number> | undefined;
+        maskRepeat?: csstype.Property.MaskRepeat | undefined;
+        maskSize?: csstype.Property.MaskSize<string | number> | undefined;
+        maskType?: csstype.Property.MaskType | undefined;
+        masonryAutoFlow?: csstype.Property.MasonryAutoFlow | undefined;
+        mathDepth?: csstype.Property.MathDepth | undefined;
+        mathShift?: csstype.Property.MathShift | undefined;
+        mathStyle?: csstype.Property.MathStyle | undefined;
+        maxBlockSize?: csstype.Property.MaxBlockSize<string | number> | undefined;
+        maxHeight?: csstype.Property.MaxHeight<string | number> | undefined;
+        maxInlineSize?: csstype.Property.MaxInlineSize<string | number> | undefined;
+        maxLines?: csstype.Property.MaxLines | undefined;
+        maxWidth?: csstype.Property.MaxWidth<string | number> | undefined;
+        minBlockSize?: csstype.Property.MinBlockSize<string | number> | undefined;
+        minHeight?: csstype.Property.MinHeight<string | number> | undefined;
+        minInlineSize?: csstype.Property.MinInlineSize<string | number> | undefined;
+        minWidth?: csstype.Property.MinWidth<string | number> | undefined;
+        mixBlendMode?: csstype.Property.MixBlendMode | undefined;
+        motionDistance?: csstype.Property.OffsetDistance<string | number> | undefined;
+        motionPath?: csstype.Property.OffsetPath | undefined;
+        motionRotation?: csstype.Property.OffsetRotate | undefined;
+        objectFit?: csstype.Property.ObjectFit | undefined;
+        objectPosition?: csstype.Property.ObjectPosition<string | number> | undefined;
+        objectViewBox?: csstype.Property.ObjectViewBox | undefined;
+        offsetAnchor?: csstype.Property.OffsetAnchor<string | number> | undefined;
+        offsetDistance?: csstype.Property.OffsetDistance<string | number> | undefined;
+        offsetPath?: csstype.Property.OffsetPath | undefined;
+        offsetPosition?: csstype.Property.OffsetPosition<string | number> | undefined;
+        offsetRotate?: csstype.Property.OffsetRotate | undefined;
+        offsetRotation?: csstype.Property.OffsetRotate | undefined;
+        opacity?: csstype.Property.Opacity | undefined;
+        order?: csstype.Property.Order | undefined;
+        orphans?: csstype.Property.Orphans | undefined;
+        outlineColor?: csstype.Property.OutlineColor | undefined;
+        outlineOffset?: csstype.Property.OutlineOffset<string | number> | undefined;
+        outlineStyle?: csstype.Property.OutlineStyle | undefined;
+        outlineWidth?: csstype.Property.OutlineWidth<string | number> | undefined;
+        overflowAnchor?: csstype.Property.OverflowAnchor | undefined;
+        overflowBlock?: csstype.Property.OverflowBlock | undefined;
+        overflowClipBox?: csstype.Property.OverflowClipBox | undefined;
+        overflowClipMargin?: csstype.Property.OverflowClipMargin<string | number> | undefined;
+        overflowInline?: csstype.Property.OverflowInline | undefined;
+        overflowWrap?: csstype.Property.OverflowWrap | undefined;
+        overflowX?: csstype.Property.OverflowX | undefined;
+        overflowY?: csstype.Property.OverflowY | undefined;
+        overlay?: csstype.Property.Overlay | undefined;
+        overscrollBehaviorBlock?: csstype.Property.OverscrollBehaviorBlock | undefined;
+        overscrollBehaviorInline?: csstype.Property.OverscrollBehaviorInline | undefined;
+        overscrollBehaviorX?: csstype.Property.OverscrollBehaviorX | undefined;
+        overscrollBehaviorY?: csstype.Property.OverscrollBehaviorY | undefined;
+        paddingBlockEnd?: csstype.Property.PaddingBlockEnd<string | number> | undefined;
+        paddingBlockStart?: csstype.Property.PaddingBlockStart<string | number> | undefined;
+        paddingBottom?: csstype.Property.PaddingBottom<string | number> | undefined;
+        paddingInlineEnd?: csstype.Property.PaddingInlineEnd<string | number> | undefined;
+        paddingInlineStart?: csstype.Property.PaddingInlineStart<string | number> | undefined;
+        paddingLeft?: csstype.Property.PaddingLeft<string | number> | undefined;
+        paddingRight?: csstype.Property.PaddingRight<string | number> | undefined;
+        paddingTop?: csstype.Property.PaddingTop<string | number> | undefined;
+        page?: csstype.Property.Page | undefined;
+        paintOrder?: csstype.Property.PaintOrder | undefined;
+        perspective?: csstype.Property.Perspective<string | number> | undefined;
+        perspectiveOrigin?: csstype.Property.PerspectiveOrigin<string | number> | undefined;
+        pointerEvents?: csstype.Property.PointerEvents | undefined;
+        position?: csstype.Property.Position | undefined;
+        positionAnchor?: csstype.Property.PositionAnchor | undefined;
+        positionArea?: csstype.Property.PositionArea | undefined;
+        positionTryFallbacks?: csstype.Property.PositionTryFallbacks | undefined;
+        positionTryOrder?: csstype.Property.PositionTryOrder | undefined;
+        positionVisibility?: csstype.Property.PositionVisibility | undefined;
+        printColorAdjust?: csstype.Property.PrintColorAdjust | undefined;
+        quotes?: csstype.Property.Quotes | undefined;
+        r?: csstype.Property.R<string | number> | undefined;
+        resize?: csstype.Property.Resize | undefined;
+        right?: csstype.Property.Right<string | number> | undefined;
+        rotate?: csstype.Property.Rotate | undefined;
+        rowGap?: csstype.Property.RowGap<string | number> | undefined;
+        rubyAlign?: csstype.Property.RubyAlign | undefined;
+        rubyMerge?: csstype.Property.RubyMerge | undefined;
+        rubyOverhang?: csstype.Property.RubyOverhang | undefined;
+        rubyPosition?: csstype.Property.RubyPosition | undefined;
+        rx?: csstype.Property.Rx<string | number> | undefined;
+        ry?: csstype.Property.Ry<string | number> | undefined;
+        scale?: csstype.Property.Scale | undefined;
+        scrollBehavior?: csstype.Property.ScrollBehavior | undefined;
+        scrollInitialTarget?: csstype.Property.ScrollInitialTarget | undefined;
+        scrollMarginBlockEnd?: csstype.Property.ScrollMarginBlockEnd<string | number> | undefined;
+        scrollMarginBlockStart?: csstype.Property.ScrollMarginBlockStart<string | number> | undefined;
+        scrollMarginBottom?: csstype.Property.ScrollMarginBottom<string | number> | undefined;
+        scrollMarginInlineEnd?: csstype.Property.ScrollMarginInlineEnd<string | number> | undefined;
+        scrollMarginInlineStart?: csstype.Property.ScrollMarginInlineStart<string | number> | undefined;
+        scrollMarginLeft?: csstype.Property.ScrollMarginLeft<string | number> | undefined;
+        scrollMarginRight?: csstype.Property.ScrollMarginRight<string | number> | undefined;
+        scrollMarginTop?: csstype.Property.ScrollMarginTop<string | number> | undefined;
+        scrollPaddingBlockEnd?: csstype.Property.ScrollPaddingBlockEnd<string | number> | undefined;
+        scrollPaddingBlockStart?: csstype.Property.ScrollPaddingBlockStart<string | number> | undefined;
+        scrollPaddingBottom?: csstype.Property.ScrollPaddingBottom<string | number> | undefined;
+        scrollPaddingInlineEnd?: csstype.Property.ScrollPaddingInlineEnd<string | number> | undefined;
+        scrollPaddingInlineStart?: csstype.Property.ScrollPaddingInlineStart<string | number> | undefined;
+        scrollPaddingLeft?: csstype.Property.ScrollPaddingLeft<string | number> | undefined;
+        scrollPaddingRight?: csstype.Property.ScrollPaddingRight<string | number> | undefined;
+        scrollPaddingTop?: csstype.Property.ScrollPaddingTop<string | number> | undefined;
+        scrollSnapAlign?: csstype.Property.ScrollSnapAlign | undefined;
+        scrollSnapMarginBottom?: csstype.Property.ScrollMarginBottom<string | number> | undefined;
+        scrollSnapMarginLeft?: csstype.Property.ScrollMarginLeft<string | number> | undefined;
+        scrollSnapMarginRight?: csstype.Property.ScrollMarginRight<string | number> | undefined;
+        scrollSnapMarginTop?: csstype.Property.ScrollMarginTop<string | number> | undefined;
+        scrollSnapStop?: csstype.Property.ScrollSnapStop | undefined;
+        scrollSnapType?: csstype.Property.ScrollSnapType | undefined;
+        scrollTimelineAxis?: csstype.Property.ScrollTimelineAxis | undefined;
+        scrollTimelineName?: csstype.Property.ScrollTimelineName | undefined;
+        scrollbarColor?: csstype.Property.ScrollbarColor | undefined;
+        scrollbarGutter?: csstype.Property.ScrollbarGutter | undefined;
+        scrollbarWidth?: csstype.Property.ScrollbarWidth | undefined;
+        shapeImageThreshold?: csstype.Property.ShapeImageThreshold | undefined;
+        shapeMargin?: csstype.Property.ShapeMargin<string | number> | undefined;
+        shapeOutside?: csstype.Property.ShapeOutside | undefined;
+        shapeRendering?: csstype.Property.ShapeRendering | undefined;
+        speakAs?: csstype.Property.SpeakAs | undefined;
+        stopColor?: csstype.Property.StopColor | undefined;
+        stopOpacity?: csstype.Property.StopOpacity | undefined;
+        stroke?: csstype.Property.Stroke | undefined;
+        strokeColor?: csstype.Property.StrokeColor | undefined;
+        strokeDasharray?: csstype.Property.StrokeDasharray<string | number> | undefined;
+        strokeDashoffset?: csstype.Property.StrokeDashoffset<string | number> | undefined;
+        strokeLinecap?: csstype.Property.StrokeLinecap | undefined;
+        strokeLinejoin?: csstype.Property.StrokeLinejoin | undefined;
+        strokeMiterlimit?: csstype.Property.StrokeMiterlimit | undefined;
+        strokeOpacity?: csstype.Property.StrokeOpacity | undefined;
+        strokeWidth?: csstype.Property.StrokeWidth<string | number> | undefined;
+        tabSize?: csstype.Property.TabSize<string | number> | undefined;
+        tableLayout?: csstype.Property.TableLayout | undefined;
+        textAlign: csstype.Property.TextAlign | undefined;
+        textAlignLast?: csstype.Property.TextAlignLast | undefined;
+        textAnchor?: csstype.Property.TextAnchor | undefined;
+        textAutospace?: csstype.Property.TextAutospace | undefined;
+        textBox?: csstype.Property.TextBox | undefined;
+        textBoxEdge?: csstype.Property.TextBoxEdge | undefined;
+        textBoxTrim?: csstype.Property.TextBoxTrim | undefined;
+        textCombineUpright?: csstype.Property.TextCombineUpright | undefined;
+        textDecorationColor?: csstype.Property.TextDecorationColor | undefined;
+        textDecorationLine?: csstype.Property.TextDecorationLine | undefined;
+        textDecorationSkip?: csstype.Property.TextDecorationSkip | undefined;
+        textDecorationSkipInk?: csstype.Property.TextDecorationSkipInk | undefined;
+        textDecorationStyle?: csstype.Property.TextDecorationStyle | undefined;
+        textDecorationThickness?: csstype.Property.TextDecorationThickness<string | number> | undefined;
+        textEmphasisColor?: csstype.Property.TextEmphasisColor | undefined;
+        textEmphasisPosition?: csstype.Property.TextEmphasisPosition | undefined;
+        textEmphasisStyle?: csstype.Property.TextEmphasisStyle | undefined;
+        textIndent?: csstype.Property.TextIndent<string | number> | undefined;
+        textJustify?: csstype.Property.TextJustify | undefined;
+        textOrientation?: csstype.Property.TextOrientation | undefined;
+        textOverflow?: csstype.Property.TextOverflow | undefined;
+        textRendering?: csstype.Property.TextRendering | undefined;
+        textShadow?: csstype.Property.TextShadow | undefined;
+        textSizeAdjust?: csstype.Property.TextSizeAdjust | undefined;
+        textSpacingTrim?: csstype.Property.TextSpacingTrim | undefined;
+        textTransform?: csstype.Property.TextTransform | undefined;
+        textUnderlineOffset?: csstype.Property.TextUnderlineOffset<string | number> | undefined;
+        textUnderlinePosition?: csstype.Property.TextUnderlinePosition | undefined;
+        textWrapMode?: csstype.Property.TextWrapMode | undefined;
+        textWrapStyle?: csstype.Property.TextWrapStyle | undefined;
+        timelineScope?: csstype.Property.TimelineScope | undefined;
+        top?: csstype.Property.Top<string | number> | undefined;
+        touchAction?: csstype.Property.TouchAction | undefined;
+        transform?: csstype.Property.Transform | undefined;
+        transformBox?: csstype.Property.TransformBox | undefined;
+        transformOrigin?: csstype.Property.TransformOrigin<string | number> | undefined;
+        transformStyle?: csstype.Property.TransformStyle | undefined;
+        transitionBehavior?: csstype.Property.TransitionBehavior | undefined;
+        transitionDelay?: csstype.Property.TransitionDelay<string & {}> | undefined;
+        transitionDuration?: csstype.Property.TransitionDuration<string & {}> | undefined;
+        transitionProperty?: csstype.Property.TransitionProperty | undefined;
+        transitionTimingFunction?: csstype.Property.TransitionTimingFunction | undefined;
+        translate?: csstype.Property.Translate<string | number> | undefined;
+        unicodeBidi?: csstype.Property.UnicodeBidi | undefined;
+        userSelect?: csstype.Property.UserSelect | undefined;
+        vectorEffect?: csstype.Property.VectorEffect | undefined;
+        verticalAlign?: csstype.Property.VerticalAlign<string | number> | undefined;
+        viewTimelineAxis?: csstype.Property.ViewTimelineAxis | undefined;
+        viewTimelineInset?: csstype.Property.ViewTimelineInset<string | number> | undefined;
+        viewTimelineName?: csstype.Property.ViewTimelineName | undefined;
+        viewTransitionClass?: csstype.Property.ViewTransitionClass | undefined;
+        viewTransitionName?: csstype.Property.ViewTransitionName | undefined;
+        visibility?: csstype.Property.Visibility | undefined;
+        whiteSpace?: csstype.Property.WhiteSpace | undefined;
+        whiteSpaceCollapse?: csstype.Property.WhiteSpaceCollapse | undefined;
+        widows?: csstype.Property.Widows | undefined;
+        width?: csstype.Property.Width<string | number> | undefined;
+        willChange?: csstype.Property.WillChange | undefined;
+        wordBreak?: csstype.Property.WordBreak | undefined;
+        wordSpacing?: csstype.Property.WordSpacing<string | number> | undefined;
+        wordWrap?: csstype.Property.WordWrap | undefined;
+        writingMode?: csstype.Property.WritingMode | undefined;
+        x?: csstype.Property.X<string | number> | undefined;
+        y?: csstype.Property.Y<string | number> | undefined;
+        zIndex?: csstype.Property.ZIndex | undefined;
+        zoom?: csstype.Property.Zoom | undefined;
+        all?: csstype.Property.All | undefined;
+        animation?: csstype.Property.Animation<string & {}> | undefined;
+        animationRange?: csstype.Property.AnimationRange<string | number> | undefined;
+        background?: csstype.Property.Background<string | number> | undefined;
+        backgroundPosition?: csstype.Property.BackgroundPosition<string | number> | undefined;
+        border?: csstype.Property.Border<string | number> | undefined;
+        borderBlock?: csstype.Property.BorderBlock<string | number> | undefined;
+        borderBlockColor?: csstype.Property.BorderBlockColor | undefined;
+        borderBlockEnd?: csstype.Property.BorderBlockEnd<string | number> | undefined;
+        borderBlockStart?: csstype.Property.BorderBlockStart<string | number> | undefined;
+        borderBlockStyle?: csstype.Property.BorderBlockStyle | undefined;
+        borderBlockWidth?: csstype.Property.BorderBlockWidth<string | number> | undefined;
+        borderBottom?: csstype.Property.BorderBottom<string | number> | undefined;
+        borderColor?: csstype.Property.BorderColor | undefined;
+        borderImage?: csstype.Property.BorderImage | undefined;
+        borderInline?: csstype.Property.BorderInline<string | number> | undefined;
+        borderInlineColor?: csstype.Property.BorderInlineColor | undefined;
+        borderInlineEnd?: csstype.Property.BorderInlineEnd<string | number> | undefined;
+        borderInlineStart?: csstype.Property.BorderInlineStart<string | number> | undefined;
+        borderInlineStyle?: csstype.Property.BorderInlineStyle | undefined;
+        borderInlineWidth?: csstype.Property.BorderInlineWidth<string | number> | undefined;
+        borderLeft?: csstype.Property.BorderLeft<string | number> | undefined;
+        borderRadius?: csstype.Property.BorderRadius<string | number> | undefined;
+        borderRight?: csstype.Property.BorderRight<string | number> | undefined;
+        borderStyle?: csstype.Property.BorderStyle | undefined;
+        borderTop?: csstype.Property.BorderTop<string | number> | undefined;
+        borderWidth?: csstype.Property.BorderWidth<string | number> | undefined;
+        caret?: csstype.Property.Caret | undefined;
+        columnRule?: csstype.Property.ColumnRule<string | number> | undefined;
+        columns?: csstype.Property.Columns<string | number> | undefined;
+        containIntrinsicSize?: csstype.Property.ContainIntrinsicSize<string | number> | undefined;
+        container?: csstype.Property.Container | undefined;
+        flex?: csstype.Property.Flex<string | number> | undefined;
+        flexFlow?: csstype.Property.FlexFlow | undefined;
+        font?: csstype.Property.Font | undefined;
+        gap?: csstype.Property.Gap<string | number> | undefined;
+        grid?: csstype.Property.Grid | undefined;
+        gridArea?: csstype.Property.GridArea | undefined;
+        gridColumn?: csstype.Property.GridColumn | undefined;
+        gridRow?: csstype.Property.GridRow | undefined;
+        gridTemplate?: csstype.Property.GridTemplate | undefined;
+        inset?: csstype.Property.Inset<string | number> | undefined;
+        insetBlock?: csstype.Property.InsetBlock<string | number> | undefined;
+        insetInline?: csstype.Property.InsetInline<string | number> | undefined;
+        lineClamp?: csstype.Property.LineClamp | undefined;
+        listStyle?: csstype.Property.ListStyle | undefined;
+        margin?: csstype.Property.Margin<string | number> | undefined;
+        marginBlock?: csstype.Property.MarginBlock<string | number> | undefined;
+        marginInline?: csstype.Property.MarginInline<string | number> | undefined;
+        mask?: csstype.Property.Mask<string | number> | undefined;
+        maskBorder?: csstype.Property.MaskBorder | undefined;
+        motion?: csstype.Property.Offset<string | number> | undefined;
+        offset?: csstype.Property.Offset<string | number> | undefined;
+        outline?: csstype.Property.Outline<string | number> | undefined;
+        overflow?: csstype.Property.Overflow | undefined;
+        overscrollBehavior?: csstype.Property.OverscrollBehavior | undefined;
+        padding?: csstype.Property.Padding<string | number> | undefined;
+        paddingBlock?: csstype.Property.PaddingBlock<string | number> | undefined;
+        paddingInline?: csstype.Property.PaddingInline<string | number> | undefined;
+        placeContent?: csstype.Property.PlaceContent | undefined;
+        placeItems?: csstype.Property.PlaceItems | undefined;
+        placeSelf?: csstype.Property.PlaceSelf | undefined;
+        positionTry?: csstype.Property.PositionTry | undefined;
+        scrollMargin?: csstype.Property.ScrollMargin<string | number> | undefined;
+        scrollMarginBlock?: csstype.Property.ScrollMarginBlock<string | number> | undefined;
+        scrollMarginInline?: csstype.Property.ScrollMarginInline<string | number> | undefined;
+        scrollPadding?: csstype.Property.ScrollPadding<string | number> | undefined;
+        scrollPaddingBlock?: csstype.Property.ScrollPaddingBlock<string | number> | undefined;
+        scrollPaddingInline?: csstype.Property.ScrollPaddingInline<string | number> | undefined;
+        scrollSnapMargin?: csstype.Property.ScrollMargin<string | number> | undefined;
+        scrollTimeline?: csstype.Property.ScrollTimeline | undefined;
+        textDecoration?: csstype.Property.TextDecoration<string | number> | undefined;
+        textEmphasis?: csstype.Property.TextEmphasis | undefined;
+        textWrap?: csstype.Property.TextWrap | undefined;
+        transition?: csstype.Property.Transition<string & {}> | undefined;
+        viewTimeline?: csstype.Property.ViewTimeline | undefined;
+        MozAnimationDelay?: csstype.Property.AnimationDelay<string & {}> | undefined;
+        MozAnimationDirection?: csstype.Property.AnimationDirection | undefined;
+        MozAnimationDuration?: csstype.Property.AnimationDuration<string & {}> | undefined;
+        MozAnimationFillMode?: csstype.Property.AnimationFillMode | undefined;
+        MozAnimationIterationCount?: csstype.Property.AnimationIterationCount | undefined;
+        MozAnimationName?: csstype.Property.AnimationName | undefined;
+        MozAnimationPlayState?: csstype.Property.AnimationPlayState | undefined;
+        MozAnimationTimingFunction?: csstype.Property.AnimationTimingFunction | undefined;
+        MozAppearance?: csstype.Property.MozAppearance | undefined;
+        MozBackfaceVisibility?: csstype.Property.BackfaceVisibility | undefined;
+        MozBinding?: csstype.Property.MozBinding | undefined;
+        MozBorderBottomColors?: csstype.Property.MozBorderBottomColors | undefined;
+        MozBorderEndColor?: csstype.Property.BorderInlineEndColor | undefined;
+        MozBorderEndStyle?: csstype.Property.BorderInlineEndStyle | undefined;
+        MozBorderEndWidth?: csstype.Property.BorderInlineEndWidth<string | number> | undefined;
+        MozBorderLeftColors?: csstype.Property.MozBorderLeftColors | undefined;
+        MozBorderRightColors?: csstype.Property.MozBorderRightColors | undefined;
+        MozBorderStartColor?: csstype.Property.BorderInlineStartColor | undefined;
+        MozBorderStartStyle?: csstype.Property.BorderInlineStartStyle | undefined;
+        MozBorderTopColors?: csstype.Property.MozBorderTopColors | undefined;
+        MozBoxSizing?: csstype.Property.BoxSizing | undefined;
+        MozColumnRuleColor?: csstype.Property.ColumnRuleColor | undefined;
+        MozColumnRuleStyle?: csstype.Property.ColumnRuleStyle | undefined;
+        MozColumnRuleWidth?: csstype.Property.ColumnRuleWidth<string | number> | undefined;
+        MozColumnWidth?: csstype.Property.ColumnWidth<string | number> | undefined;
+        MozContextProperties?: csstype.Property.MozContextProperties | undefined;
+        MozFontFeatureSettings?: csstype.Property.FontFeatureSettings | undefined;
+        MozFontLanguageOverride?: csstype.Property.FontLanguageOverride | undefined;
+        MozHyphens?: csstype.Property.Hyphens | undefined;
+        MozMarginEnd?: csstype.Property.MarginInlineEnd<string | number> | undefined;
+        MozMarginStart?: csstype.Property.MarginInlineStart<string | number> | undefined;
+        MozOrient?: csstype.Property.MozOrient | undefined;
+        MozOsxFontSmoothing?: csstype.Property.FontSmooth<string | number> | undefined;
+        MozOutlineRadiusBottomleft?: csstype.Property.MozOutlineRadiusBottomleft<string | number> | undefined;
+        MozOutlineRadiusBottomright?: csstype.Property.MozOutlineRadiusBottomright<string | number> | undefined;
+        MozOutlineRadiusTopleft?: csstype.Property.MozOutlineRadiusTopleft<string | number> | undefined;
+        MozOutlineRadiusTopright?: csstype.Property.MozOutlineRadiusTopright<string | number> | undefined;
+        MozPaddingEnd?: csstype.Property.PaddingInlineEnd<string | number> | undefined;
+        MozPaddingStart?: csstype.Property.PaddingInlineStart<string | number> | undefined;
+        MozPerspective?: csstype.Property.Perspective<string | number> | undefined;
+        MozPerspectiveOrigin?: csstype.Property.PerspectiveOrigin<string | number> | undefined;
+        MozStackSizing?: csstype.Property.MozStackSizing | undefined;
+        MozTabSize?: csstype.Property.TabSize<string | number> | undefined;
+        MozTextBlink?: csstype.Property.MozTextBlink | undefined;
+        MozTextSizeAdjust?: csstype.Property.TextSizeAdjust | undefined;
+        MozTransform?: csstype.Property.Transform | undefined;
+        MozTransformOrigin?: csstype.Property.TransformOrigin<string | number> | undefined;
+        MozTransformStyle?: csstype.Property.TransformStyle | undefined;
+        MozUserModify?: csstype.Property.MozUserModify | undefined;
+        MozUserSelect?: csstype.Property.UserSelect | undefined;
+        MozWindowDragging?: csstype.Property.MozWindowDragging | undefined;
+        MozWindowShadow?: csstype.Property.MozWindowShadow | undefined;
+        msAccelerator?: csstype.Property.MsAccelerator | undefined;
+        msBlockProgression?: csstype.Property.MsBlockProgression | undefined;
+        msContentZoomChaining?: csstype.Property.MsContentZoomChaining | undefined;
+        msContentZoomLimitMax?: csstype.Property.MsContentZoomLimitMax | undefined;
+        msContentZoomLimitMin?: csstype.Property.MsContentZoomLimitMin | undefined;
+        msContentZoomSnapPoints?: csstype.Property.MsContentZoomSnapPoints | undefined;
+        msContentZoomSnapType?: csstype.Property.MsContentZoomSnapType | undefined;
+        msContentZooming?: csstype.Property.MsContentZooming | undefined;
+        msFilter?: csstype.Property.MsFilter | undefined;
+        msFlexDirection?: csstype.Property.FlexDirection | undefined;
+        msFlexPositive?: csstype.Property.FlexGrow | undefined;
+        msFlowFrom?: csstype.Property.MsFlowFrom | undefined;
+        msFlowInto?: csstype.Property.MsFlowInto | undefined;
+        msGridColumns?: csstype.Property.MsGridColumns<string | number> | undefined;
+        msGridRows?: csstype.Property.MsGridRows<string | number> | undefined;
+        msHighContrastAdjust?: csstype.Property.MsHighContrastAdjust | undefined;
+        msHyphenateLimitChars?: csstype.Property.MsHyphenateLimitChars | undefined;
+        msHyphenateLimitLines?: csstype.Property.MsHyphenateLimitLines | undefined;
+        msHyphenateLimitZone?: csstype.Property.MsHyphenateLimitZone<string | number> | undefined;
+        msHyphens?: csstype.Property.Hyphens | undefined;
+        msImeAlign?: csstype.Property.MsImeAlign | undefined;
+        msLineBreak?: csstype.Property.LineBreak | undefined;
+        msOrder?: csstype.Property.Order | undefined;
+        msOverflowStyle?: csstype.Property.MsOverflowStyle | undefined;
+        msOverflowX?: csstype.Property.OverflowX | undefined;
+        msOverflowY?: csstype.Property.OverflowY | undefined;
+        msScrollChaining?: csstype.Property.MsScrollChaining | undefined;
+        msScrollLimitXMax?: csstype.Property.MsScrollLimitXMax<string | number> | undefined;
+        msScrollLimitXMin?: csstype.Property.MsScrollLimitXMin<string | number> | undefined;
+        msScrollLimitYMax?: csstype.Property.MsScrollLimitYMax<string | number> | undefined;
+        msScrollLimitYMin?: csstype.Property.MsScrollLimitYMin<string | number> | undefined;
+        msScrollRails?: csstype.Property.MsScrollRails | undefined;
+        msScrollSnapPointsX?: csstype.Property.MsScrollSnapPointsX | undefined;
+        msScrollSnapPointsY?: csstype.Property.MsScrollSnapPointsY | undefined;
+        msScrollSnapType?: csstype.Property.MsScrollSnapType | undefined;
+        msScrollTranslation?: csstype.Property.MsScrollTranslation | undefined;
+        msScrollbar3dlightColor?: csstype.Property.MsScrollbar3dlightColor | undefined;
+        msScrollbarArrowColor?: csstype.Property.MsScrollbarArrowColor | undefined;
+        msScrollbarBaseColor?: csstype.Property.MsScrollbarBaseColor | undefined;
+        msScrollbarDarkshadowColor?: csstype.Property.MsScrollbarDarkshadowColor | undefined;
+        msScrollbarFaceColor?: csstype.Property.MsScrollbarFaceColor | undefined;
+        msScrollbarHighlightColor?: csstype.Property.MsScrollbarHighlightColor | undefined;
+        msScrollbarShadowColor?: csstype.Property.MsScrollbarShadowColor | undefined;
+        msScrollbarTrackColor?: csstype.Property.MsScrollbarTrackColor | undefined;
+        msTextAutospace?: csstype.Property.MsTextAutospace | undefined;
+        msTextCombineHorizontal?: csstype.Property.TextCombineUpright | undefined;
+        msTextOverflow?: csstype.Property.TextOverflow | undefined;
+        msTouchAction?: csstype.Property.TouchAction | undefined;
+        msTouchSelect?: csstype.Property.MsTouchSelect | undefined;
+        msTransform?: csstype.Property.Transform | undefined;
+        msTransformOrigin?: csstype.Property.TransformOrigin<string | number> | undefined;
+        msTransitionDelay?: csstype.Property.TransitionDelay<string & {}> | undefined;
+        msTransitionDuration?: csstype.Property.TransitionDuration<string & {}> | undefined;
+        msTransitionProperty?: csstype.Property.TransitionProperty | undefined;
+        msTransitionTimingFunction?: csstype.Property.TransitionTimingFunction | undefined;
+        msUserSelect?: csstype.Property.MsUserSelect | undefined;
+        msWordBreak?: csstype.Property.WordBreak | undefined;
+        msWrapFlow?: csstype.Property.MsWrapFlow | undefined;
+        msWrapMargin?: csstype.Property.MsWrapMargin<string | number> | undefined;
+        msWrapThrough?: csstype.Property.MsWrapThrough | undefined;
+        msWritingMode?: csstype.Property.WritingMode | undefined;
+        WebkitAlignContent?: csstype.Property.AlignContent | undefined;
+        WebkitAlignItems?: csstype.Property.AlignItems | undefined;
+        WebkitAlignSelf?: csstype.Property.AlignSelf | undefined;
+        WebkitAnimationDelay?: csstype.Property.AnimationDelay<string & {}> | undefined;
+        WebkitAnimationDirection?: csstype.Property.AnimationDirection | undefined;
+        WebkitAnimationDuration?: csstype.Property.AnimationDuration<string & {}> | undefined;
+        WebkitAnimationFillMode?: csstype.Property.AnimationFillMode | undefined;
+        WebkitAnimationIterationCount?: csstype.Property.AnimationIterationCount | undefined;
+        WebkitAnimationName?: csstype.Property.AnimationName | undefined;
+        WebkitAnimationPlayState?: csstype.Property.AnimationPlayState | undefined;
+        WebkitAnimationTimingFunction?: csstype.Property.AnimationTimingFunction | undefined;
+        WebkitAppearance?: csstype.Property.WebkitAppearance | undefined;
+        WebkitBackdropFilter?: csstype.Property.BackdropFilter | undefined;
+        WebkitBackfaceVisibility?: csstype.Property.BackfaceVisibility | undefined;
+        WebkitBackgroundClip?: csstype.Property.BackgroundClip | undefined;
+        WebkitBackgroundOrigin?: csstype.Property.BackgroundOrigin | undefined;
+        WebkitBackgroundSize?: csstype.Property.BackgroundSize<string | number> | undefined;
+        WebkitBorderBeforeColor?: csstype.Property.WebkitBorderBeforeColor | undefined;
+        WebkitBorderBeforeStyle?: csstype.Property.WebkitBorderBeforeStyle | undefined;
+        WebkitBorderBeforeWidth?: csstype.Property.WebkitBorderBeforeWidth<string | number> | undefined;
+        WebkitBorderBottomLeftRadius?: csstype.Property.BorderBottomLeftRadius<string | number> | undefined;
+        WebkitBorderBottomRightRadius?: csstype.Property.BorderBottomRightRadius<string | number> | undefined;
+        WebkitBorderImageSlice?: csstype.Property.BorderImageSlice | undefined;
+        WebkitBorderTopLeftRadius?: csstype.Property.BorderTopLeftRadius<string | number> | undefined;
+        WebkitBorderTopRightRadius?: csstype.Property.BorderTopRightRadius<string | number> | undefined;
+        WebkitBoxDecorationBreak?: csstype.Property.BoxDecorationBreak | undefined;
+        WebkitBoxReflect?: csstype.Property.WebkitBoxReflect<string | number> | undefined;
+        WebkitBoxShadow?: csstype.Property.BoxShadow | undefined;
+        WebkitBoxSizing?: csstype.Property.BoxSizing | undefined;
+        WebkitClipPath?: csstype.Property.ClipPath | undefined;
+        WebkitColumnCount?: csstype.Property.ColumnCount | undefined;
+        WebkitColumnFill?: csstype.Property.ColumnFill | undefined;
+        WebkitColumnRuleColor?: csstype.Property.ColumnRuleColor | undefined;
+        WebkitColumnRuleStyle?: csstype.Property.ColumnRuleStyle | undefined;
+        WebkitColumnRuleWidth?: csstype.Property.ColumnRuleWidth<string | number> | undefined;
+        WebkitColumnSpan?: csstype.Property.ColumnSpan | undefined;
+        WebkitColumnWidth?: csstype.Property.ColumnWidth<string | number> | undefined;
+        WebkitFilter?: csstype.Property.Filter | undefined;
+        WebkitFlexBasis?: csstype.Property.FlexBasis<string | number> | undefined;
+        WebkitFlexDirection?: csstype.Property.FlexDirection | undefined;
+        WebkitFlexGrow?: csstype.Property.FlexGrow | undefined;
+        WebkitFlexShrink?: csstype.Property.FlexShrink | undefined;
+        WebkitFlexWrap?: csstype.Property.FlexWrap | undefined;
+        WebkitFontFeatureSettings?: csstype.Property.FontFeatureSettings | undefined;
+        WebkitFontKerning?: csstype.Property.FontKerning | undefined;
+        WebkitFontSmoothing?: csstype.Property.FontSmooth<string | number> | undefined;
+        WebkitFontVariantLigatures?: csstype.Property.FontVariantLigatures | undefined;
+        WebkitHyphenateCharacter?: csstype.Property.HyphenateCharacter | undefined;
+        WebkitHyphens?: csstype.Property.Hyphens | undefined;
+        WebkitInitialLetter?: csstype.Property.InitialLetter | undefined;
+        WebkitJustifyContent?: csstype.Property.JustifyContent | undefined;
+        WebkitLineBreak?: csstype.Property.LineBreak | undefined;
+        WebkitLineClamp?: csstype.Property.WebkitLineClamp | undefined;
+        WebkitLogicalHeight?: csstype.Property.BlockSize<string | number> | undefined;
+        WebkitLogicalWidth?: csstype.Property.InlineSize<string | number> | undefined;
+        WebkitMarginEnd?: csstype.Property.MarginInlineEnd<string | number> | undefined;
+        WebkitMarginStart?: csstype.Property.MarginInlineStart<string | number> | undefined;
+        WebkitMaskAttachment?: csstype.Property.WebkitMaskAttachment | undefined;
+        WebkitMaskBoxImageOutset?: csstype.Property.MaskBorderOutset<string | number> | undefined;
+        WebkitMaskBoxImageRepeat?: csstype.Property.MaskBorderRepeat | undefined;
+        WebkitMaskBoxImageSlice?: csstype.Property.MaskBorderSlice | undefined;
+        WebkitMaskBoxImageSource?: csstype.Property.MaskBorderSource | undefined;
+        WebkitMaskBoxImageWidth?: csstype.Property.MaskBorderWidth<string | number> | undefined;
+        WebkitMaskClip?: csstype.Property.WebkitMaskClip | undefined;
+        WebkitMaskComposite?: csstype.Property.WebkitMaskComposite | undefined;
+        WebkitMaskImage?: csstype.Property.WebkitMaskImage | undefined;
+        WebkitMaskOrigin?: csstype.Property.WebkitMaskOrigin | undefined;
+        WebkitMaskPosition?: csstype.Property.WebkitMaskPosition<string | number> | undefined;
+        WebkitMaskPositionX?: csstype.Property.WebkitMaskPositionX<string | number> | undefined;
+        WebkitMaskPositionY?: csstype.Property.WebkitMaskPositionY<string | number> | undefined;
+        WebkitMaskRepeat?: csstype.Property.WebkitMaskRepeat | undefined;
+        WebkitMaskRepeatX?: csstype.Property.WebkitMaskRepeatX | undefined;
+        WebkitMaskRepeatY?: csstype.Property.WebkitMaskRepeatY | undefined;
+        WebkitMaskSize?: csstype.Property.WebkitMaskSize<string | number> | undefined;
+        WebkitMaxInlineSize?: csstype.Property.MaxInlineSize<string | number> | undefined;
+        WebkitOrder?: csstype.Property.Order | undefined;
+        WebkitOverflowScrolling?: csstype.Property.WebkitOverflowScrolling | undefined;
+        WebkitPaddingEnd?: csstype.Property.PaddingInlineEnd<string | number> | undefined;
+        WebkitPaddingStart?: csstype.Property.PaddingInlineStart<string | number> | undefined;
+        WebkitPerspective?: csstype.Property.Perspective<string | number> | undefined;
+        WebkitPerspectiveOrigin?: csstype.Property.PerspectiveOrigin<string | number> | undefined;
+        WebkitPrintColorAdjust?: csstype.Property.PrintColorAdjust | undefined;
+        WebkitRubyPosition?: csstype.Property.RubyPosition | undefined;
+        WebkitScrollSnapType?: csstype.Property.ScrollSnapType | undefined;
+        WebkitShapeMargin?: csstype.Property.ShapeMargin<string | number> | undefined;
+        WebkitTapHighlightColor?: csstype.Property.WebkitTapHighlightColor | undefined;
+        WebkitTextCombine?: csstype.Property.TextCombineUpright | undefined;
+        WebkitTextDecorationColor?: csstype.Property.TextDecorationColor | undefined;
+        WebkitTextDecorationLine?: csstype.Property.TextDecorationLine | undefined;
+        WebkitTextDecorationSkip?: csstype.Property.TextDecorationSkip | undefined;
+        WebkitTextDecorationStyle?: csstype.Property.TextDecorationStyle | undefined;
+        WebkitTextEmphasisColor?: csstype.Property.TextEmphasisColor | undefined;
+        WebkitTextEmphasisPosition?: csstype.Property.TextEmphasisPosition | undefined;
+        WebkitTextEmphasisStyle?: csstype.Property.TextEmphasisStyle | undefined;
+        WebkitTextFillColor?: csstype.Property.WebkitTextFillColor | undefined;
+        WebkitTextOrientation?: csstype.Property.TextOrientation | undefined;
+        WebkitTextSizeAdjust?: csstype.Property.TextSizeAdjust | undefined;
+        WebkitTextStrokeColor?: csstype.Property.WebkitTextStrokeColor | undefined;
+        WebkitTextStrokeWidth?: csstype.Property.WebkitTextStrokeWidth<string | number> | undefined;
+        WebkitTextUnderlinePosition?: csstype.Property.TextUnderlinePosition | undefined;
+        WebkitTouchCallout?: csstype.Property.WebkitTouchCallout | undefined;
+        WebkitTransform?: csstype.Property.Transform | undefined;
+        WebkitTransformOrigin?: csstype.Property.TransformOrigin<string | number> | undefined;
+        WebkitTransformStyle?: csstype.Property.TransformStyle | undefined;
+        WebkitTransitionDelay?: csstype.Property.TransitionDelay<string & {}> | undefined;
+        WebkitTransitionDuration?: csstype.Property.TransitionDuration<string & {}> | undefined;
+        WebkitTransitionProperty?: csstype.Property.TransitionProperty | undefined;
+        WebkitTransitionTimingFunction?: csstype.Property.TransitionTimingFunction | undefined;
+        WebkitUserModify?: csstype.Property.WebkitUserModify | undefined;
+        WebkitUserSelect?: csstype.Property.WebkitUserSelect | undefined;
+        WebkitWritingMode?: csstype.Property.WritingMode | undefined;
+        MozAnimation?: csstype.Property.Animation<string & {}> | undefined;
+        MozBorderImage?: csstype.Property.BorderImage | undefined;
+        MozColumnRule?: csstype.Property.ColumnRule<string | number> | undefined;
+        MozColumns?: csstype.Property.Columns<string | number> | undefined;
+        MozOutlineRadius?: csstype.Property.MozOutlineRadius<string | number> | undefined;
+        MozTransition?: csstype.Property.Transition<string & {}> | undefined;
+        msContentZoomLimit?: csstype.Property.MsContentZoomLimit | undefined;
+        msContentZoomSnap?: csstype.Property.MsContentZoomSnap | undefined;
+        msFlex?: csstype.Property.Flex<string | number> | undefined;
+        msScrollLimit?: csstype.Property.MsScrollLimit | undefined;
+        msScrollSnapX?: csstype.Property.MsScrollSnapX | undefined;
+        msScrollSnapY?: csstype.Property.MsScrollSnapY | undefined;
+        msTransition?: csstype.Property.Transition<string & {}> | undefined;
+        WebkitAnimation?: csstype.Property.Animation<string & {}> | undefined;
+        WebkitBorderBefore?: csstype.Property.WebkitBorderBefore<string | number> | undefined;
+        WebkitBorderImage?: csstype.Property.BorderImage | undefined;
+        WebkitBorderRadius?: csstype.Property.BorderRadius<string | number> | undefined;
+        WebkitColumnRule?: csstype.Property.ColumnRule<string | number> | undefined;
+        WebkitColumns?: csstype.Property.Columns<string | number> | undefined;
+        WebkitFlex?: csstype.Property.Flex<string | number> | undefined;
+        WebkitFlexFlow?: csstype.Property.FlexFlow | undefined;
+        WebkitMask?: csstype.Property.WebkitMask<string | number> | undefined;
+        WebkitMaskBoxImage?: csstype.Property.MaskBorder | undefined;
+        WebkitTextEmphasis?: csstype.Property.TextEmphasis | undefined;
+        WebkitTextStroke?: csstype.Property.WebkitTextStroke<string | number> | undefined;
+        WebkitTransition?: csstype.Property.Transition<string & {}> | undefined;
+        boxAlign?: csstype.Property.BoxAlign | undefined;
+        boxDirection?: csstype.Property.BoxDirection | undefined;
+        boxFlex?: csstype.Property.BoxFlex | undefined;
+        boxFlexGroup?: csstype.Property.BoxFlexGroup | undefined;
+        boxLines?: csstype.Property.BoxLines | undefined;
+        boxOrdinalGroup?: csstype.Property.BoxOrdinalGroup | undefined;
+        boxOrient?: csstype.Property.BoxOrient | undefined;
+        boxPack?: csstype.Property.BoxPack | undefined;
+        clip?: csstype.Property.Clip | undefined;
+        fontStretch?: csstype.Property.FontStretch | undefined;
+        gridColumnGap?: csstype.Property.GridColumnGap<string | number> | undefined;
+        gridGap?: csstype.Property.GridGap<string | number> | undefined;
+        gridRowGap?: csstype.Property.GridRowGap<string | number> | undefined;
+        imeMode?: csstype.Property.ImeMode | undefined;
+        insetArea?: csstype.Property.PositionArea | undefined;
+        offsetBlock?: csstype.Property.InsetBlock<string | number> | undefined;
+        offsetBlockEnd?: csstype.Property.InsetBlockEnd<string | number> | undefined;
+        offsetBlockStart?: csstype.Property.InsetBlockStart<string | number> | undefined;
+        offsetInline?: csstype.Property.InsetInline<string | number> | undefined;
+        offsetInlineEnd?: csstype.Property.InsetInlineEnd<string | number> | undefined;
+        offsetInlineStart?: csstype.Property.InsetInlineStart<string | number> | undefined;
+        pageBreakAfter?: csstype.Property.PageBreakAfter | undefined;
+        pageBreakBefore?: csstype.Property.PageBreakBefore | undefined;
+        pageBreakInside?: csstype.Property.PageBreakInside | undefined;
+        positionTryOptions?: csstype.Property.PositionTryFallbacks | undefined;
+        scrollSnapCoordinate?: csstype.Property.ScrollSnapCoordinate<string | number> | undefined;
+        scrollSnapDestination?: csstype.Property.ScrollSnapDestination<string | number> | undefined;
+        scrollSnapPointsX?: csstype.Property.ScrollSnapPointsX | undefined;
+        scrollSnapPointsY?: csstype.Property.ScrollSnapPointsY | undefined;
+        scrollSnapTypeX?: csstype.Property.ScrollSnapTypeX | undefined;
+        scrollSnapTypeY?: csstype.Property.ScrollSnapTypeY | undefined;
+        KhtmlBoxAlign?: csstype.Property.BoxAlign | undefined;
+        KhtmlBoxDirection?: csstype.Property.BoxDirection | undefined;
+        KhtmlBoxFlex?: csstype.Property.BoxFlex | undefined;
+        KhtmlBoxFlexGroup?: csstype.Property.BoxFlexGroup | undefined;
+        KhtmlBoxLines?: csstype.Property.BoxLines | undefined;
+        KhtmlBoxOrdinalGroup?: csstype.Property.BoxOrdinalGroup | undefined;
+        KhtmlBoxOrient?: csstype.Property.BoxOrient | undefined;
+        KhtmlBoxPack?: csstype.Property.BoxPack | undefined;
+        KhtmlLineBreak?: csstype.Property.LineBreak | undefined;
+        KhtmlOpacity?: csstype.Property.Opacity | undefined;
+        KhtmlUserSelect?: csstype.Property.UserSelect | undefined;
+        MozBackgroundClip?: csstype.Property.BackgroundClip | undefined;
+        MozBackgroundOrigin?: csstype.Property.BackgroundOrigin | undefined;
+        MozBackgroundSize?: csstype.Property.BackgroundSize<string | number> | undefined;
+        MozBorderRadius?: csstype.Property.BorderRadius<string | number> | undefined;
+        MozBorderRadiusBottomleft?: csstype.Property.BorderBottomLeftRadius<string | number> | undefined;
+        MozBorderRadiusBottomright?: csstype.Property.BorderBottomRightRadius<string | number> | undefined;
+        MozBorderRadiusTopleft?: csstype.Property.BorderTopLeftRadius<string | number> | undefined;
+        MozBorderRadiusTopright?: csstype.Property.BorderTopRightRadius<string | number> | undefined;
+        MozBoxAlign?: csstype.Property.BoxAlign | undefined;
+        MozBoxDirection?: csstype.Property.BoxDirection | undefined;
+        MozBoxFlex?: csstype.Property.BoxFlex | undefined;
+        MozBoxOrdinalGroup?: csstype.Property.BoxOrdinalGroup | undefined;
+        MozBoxOrient?: csstype.Property.BoxOrient | undefined;
+        MozBoxPack?: csstype.Property.BoxPack | undefined;
+        MozBoxShadow?: csstype.Property.BoxShadow | undefined;
+        MozColumnCount?: csstype.Property.ColumnCount | undefined;
+        MozColumnFill?: csstype.Property.ColumnFill | undefined;
+        MozFloatEdge?: csstype.Property.MozFloatEdge | undefined;
+        MozForceBrokenImageIcon?: csstype.Property.MozForceBrokenImageIcon | undefined;
+        MozOpacity?: csstype.Property.Opacity | undefined;
+        MozOutline?: csstype.Property.Outline<string | number> | undefined;
+        MozOutlineColor?: csstype.Property.OutlineColor | undefined;
+        MozOutlineStyle?: csstype.Property.OutlineStyle | undefined;
+        MozOutlineWidth?: csstype.Property.OutlineWidth<string | number> | undefined;
+        MozTextAlignLast?: csstype.Property.TextAlignLast | undefined;
+        MozTextDecorationColor?: csstype.Property.TextDecorationColor | undefined;
+        MozTextDecorationLine?: csstype.Property.TextDecorationLine | undefined;
+        MozTextDecorationStyle?: csstype.Property.TextDecorationStyle | undefined;
+        MozTransitionDelay?: csstype.Property.TransitionDelay<string & {}> | undefined;
+        MozTransitionDuration?: csstype.Property.TransitionDuration<string & {}> | undefined;
+        MozTransitionProperty?: csstype.Property.TransitionProperty | undefined;
+        MozTransitionTimingFunction?: csstype.Property.TransitionTimingFunction | undefined;
+        MozUserFocus?: csstype.Property.MozUserFocus | undefined;
+        MozUserInput?: csstype.Property.MozUserInput | undefined;
+        msImeMode?: csstype.Property.ImeMode | undefined;
+        OAnimation?: csstype.Property.Animation<string & {}> | undefined;
+        OAnimationDelay?: csstype.Property.AnimationDelay<string & {}> | undefined;
+        OAnimationDirection?: csstype.Property.AnimationDirection | undefined;
+        OAnimationDuration?: csstype.Property.AnimationDuration<string & {}> | undefined;
+        OAnimationFillMode?: csstype.Property.AnimationFillMode | undefined;
+        OAnimationIterationCount?: csstype.Property.AnimationIterationCount | undefined;
+        OAnimationName?: csstype.Property.AnimationName | undefined;
+        OAnimationPlayState?: csstype.Property.AnimationPlayState | undefined;
+        OAnimationTimingFunction?: csstype.Property.AnimationTimingFunction | undefined;
+        OBackgroundSize?: csstype.Property.BackgroundSize<string | number> | undefined;
+        OBorderImage?: csstype.Property.BorderImage | undefined;
+        OObjectFit?: csstype.Property.ObjectFit | undefined;
+        OObjectPosition?: csstype.Property.ObjectPosition<string | number> | undefined;
+        OTabSize?: csstype.Property.TabSize<string | number> | undefined;
+        OTextOverflow?: csstype.Property.TextOverflow | undefined;
+        OTransform?: csstype.Property.Transform | undefined;
+        OTransformOrigin?: csstype.Property.TransformOrigin<string | number> | undefined;
+        OTransition?: csstype.Property.Transition<string & {}> | undefined;
+        OTransitionDelay?: csstype.Property.TransitionDelay<string & {}> | undefined;
+        OTransitionDuration?: csstype.Property.TransitionDuration<string & {}> | undefined;
+        OTransitionProperty?: csstype.Property.TransitionProperty | undefined;
+        OTransitionTimingFunction?: csstype.Property.TransitionTimingFunction | undefined;
+        WebkitBoxAlign?: csstype.Property.BoxAlign | undefined;
+        WebkitBoxDirection?: csstype.Property.BoxDirection | undefined;
+        WebkitBoxFlex?: csstype.Property.BoxFlex | undefined;
+        WebkitBoxFlexGroup?: csstype.Property.BoxFlexGroup | undefined;
+        WebkitBoxLines?: csstype.Property.BoxLines | undefined;
+        WebkitBoxOrdinalGroup?: csstype.Property.BoxOrdinalGroup | undefined;
+        WebkitBoxOrient?: csstype.Property.BoxOrient | undefined;
+        WebkitBoxPack?: csstype.Property.BoxPack | undefined;
+        colorInterpolation?: csstype.Property.ColorInterpolation | undefined;
+        colorRendering?: csstype.Property.ColorRendering | undefined;
+        glyphOrientationVertical?: csstype.Property.GlyphOrientationVertical | undefined;
+    };
+    defaultChecked?: boolean | undefined;
+    defaultValue?: string | number | readonly string[] | undefined;
+    suppressContentEditableWarning?: boolean | undefined;
+    suppressHydrationWarning?: boolean | undefined;
+    accessKey?: string | undefined;
+    autoCapitalize?: "off" | "none" | "on" | "sentences" | "words" | "characters" | undefined | (string & {});
+    autoFocus?: boolean | undefined;
+    contentEditable?: (boolean | "false" | "true") | "inherit" | "plaintext-only" | undefined;
+    contextMenu?: string | undefined;
+    dir?: string | undefined;
+    draggable?: (boolean | "false" | "true") | undefined;
+    enterKeyHint?: "enter" | "done" | "go" | "next" | "previous" | "search" | "send" | undefined;
+    hidden?: boolean | undefined;
+    id?: string | undefined;
+    lang?: string | undefined;
+    nonce?: string | undefined;
+    slot?: string | undefined;
+    spellCheck?: (boolean | "false" | "true") | undefined;
+    tabIndex?: number | undefined;
+    title?: string | undefined;
+    translate?: "yes" | "no" | undefined;
+    radioGroup?: string | undefined;
+    role?: React__default.AriaRole | undefined;
+    about?: string | undefined;
+    content?: string | undefined;
+    datatype?: string | undefined;
+    inlist?: any;
+    prefix?: string | undefined;
+    property?: string | undefined;
+    rel?: string | undefined;
+    resource?: string | undefined;
+    rev?: string | undefined;
+    typeof?: string | undefined;
+    vocab?: string | undefined;
+    autoCorrect?: string | undefined;
+    autoSave?: string | undefined;
+    itemProp?: string | undefined;
+    itemScope?: boolean | undefined;
+    itemType?: string | undefined;
+    itemID?: string | undefined;
+    itemRef?: string | undefined;
+    results?: number | undefined;
+    security?: string | undefined;
+    unselectable?: "on" | "off" | undefined;
+    popover?: "" | "auto" | "manual" | "hint" | undefined;
+    popoverTargetAction?: "toggle" | "show" | "hide" | undefined;
+    popoverTarget?: string | undefined;
+    inert?: boolean | undefined;
+    inputMode?: "none" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | "search" | undefined;
+    is?: string | undefined;
+    exportparts?: string | undefined;
+    part?: string | undefined;
+    "aria-activedescendant"?: string | undefined;
+    "aria-atomic"?: (boolean | "false" | "true") | undefined;
+    "aria-autocomplete"?: "none" | "inline" | "list" | "both" | undefined;
+    "aria-braillelabel"?: string | undefined;
+    "aria-brailleroledescription"?: string | undefined;
+    "aria-busy"?: (boolean | "false" | "true") | undefined;
+    "aria-checked"?: boolean | "false" | "mixed" | "true" | undefined;
+    "aria-colcount"?: number | undefined;
+    "aria-colindex"?: number | undefined;
+    "aria-colindextext"?: string | undefined;
+    "aria-colspan"?: number | undefined;
+    "aria-controls"?: string | undefined;
+    "aria-current"?: boolean | "false" | "true" | "page" | "step" | "location" | "date" | "time" | undefined;
+    "aria-describedby"?: string | undefined;
+    "aria-description"?: string | undefined;
+    "aria-details"?: string | undefined;
+    "aria-disabled"?: (boolean | "false" | "true") | undefined;
+    "aria-dropeffect"?: "none" | "copy" | "execute" | "link" | "move" | "popup" | undefined;
+    "aria-errormessage"?: string | undefined;
+    "aria-expanded"?: (boolean | "false" | "true") | undefined;
+    "aria-flowto"?: string | undefined;
+    "aria-grabbed"?: (boolean | "false" | "true") | undefined;
+    "aria-haspopup"?: boolean | "false" | "true" | "menu" | "listbox" | "tree" | "grid" | "dialog" | undefined;
+    "aria-hidden"?: (boolean | "false" | "true") | undefined;
+    "aria-invalid"?: boolean | "false" | "true" | "grammar" | "spelling" | undefined;
+    "aria-keyshortcuts"?: string | undefined;
+    "aria-label"?: string | undefined;
+    "aria-labelledby"?: string | undefined;
+    "aria-level"?: number | undefined;
+    "aria-live"?: "off" | "assertive" | "polite" | undefined;
+    "aria-modal"?: (boolean | "false" | "true") | undefined;
+    "aria-multiline"?: (boolean | "false" | "true") | undefined;
+    "aria-multiselectable"?: (boolean | "false" | "true") | undefined;
+    "aria-orientation"?: "horizontal" | "vertical" | undefined;
+    "aria-owns"?: string | undefined;
+    "aria-placeholder"?: string | undefined;
+    "aria-posinset"?: number | undefined;
+    "aria-pressed"?: boolean | "false" | "mixed" | "true" | undefined;
+    "aria-readonly"?: (boolean | "false" | "true") | undefined;
+    "aria-relevant"?: "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text" | "text additions" | "text removals" | undefined;
+    "aria-required"?: (boolean | "false" | "true") | undefined;
+    "aria-roledescription"?: string | undefined;
+    "aria-rowcount"?: number | undefined;
+    "aria-rowindex"?: number | undefined;
+    "aria-rowindextext"?: string | undefined;
+    "aria-rowspan"?: number | undefined;
+    "aria-selected"?: (boolean | "false" | "true") | undefined;
+    "aria-setsize"?: number | undefined;
+    "aria-sort"?: "none" | "ascending" | "descending" | "other" | undefined;
+    "aria-valuemax"?: number | undefined;
+    "aria-valuemin"?: number | undefined;
+    "aria-valuenow"?: number | undefined;
+    "aria-valuetext"?: string | undefined;
+    dangerouslySetInnerHTML?: {
+        __html: string | TrustedHTML;
+    } | undefined;
+    onCopy?: React__default.ClipboardEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onCopyCapture?: React__default.ClipboardEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onCut?: React__default.ClipboardEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onCutCapture?: React__default.ClipboardEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onPaste?: React__default.ClipboardEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onPasteCapture?: React__default.ClipboardEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onCompositionEnd?: React__default.CompositionEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onCompositionEndCapture?: React__default.CompositionEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onCompositionStart?: React__default.CompositionEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onCompositionStartCapture?: React__default.CompositionEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onCompositionUpdate?: React__default.CompositionEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onCompositionUpdateCapture?: React__default.CompositionEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onFocus?: React__default.FocusEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onFocusCapture?: React__default.FocusEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onBlur?: React__default.FocusEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onBlurCapture?: React__default.FocusEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onChange?: React__default.FormEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onChangeCapture?: React__default.FormEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onBeforeInput?: React__default.InputEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onBeforeInputCapture?: React__default.FormEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onInput?: React__default.FormEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onInputCapture?: React__default.FormEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onReset?: React__default.FormEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onResetCapture?: React__default.FormEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onSubmit?: React__default.FormEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onSubmitCapture?: React__default.FormEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onInvalid?: React__default.FormEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onInvalidCapture?: React__default.FormEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onLoad?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onLoadCapture?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onError?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onErrorCapture?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onKeyDown?: React__default.KeyboardEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onKeyDownCapture?: React__default.KeyboardEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onKeyPress?: React__default.KeyboardEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onKeyPressCapture?: React__default.KeyboardEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onKeyUp?: React__default.KeyboardEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onKeyUpCapture?: React__default.KeyboardEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onAbort?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onAbortCapture?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onCanPlay?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onCanPlayCapture?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onCanPlayThrough?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onCanPlayThroughCapture?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onDurationChange?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onDurationChangeCapture?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onEmptied?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onEmptiedCapture?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onEncrypted?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onEncryptedCapture?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onEnded?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onEndedCapture?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onLoadedData?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onLoadedDataCapture?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onLoadedMetadata?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onLoadedMetadataCapture?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onLoadStart?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onLoadStartCapture?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onPause?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onPauseCapture?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onPlay?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onPlayCapture?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onPlaying?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onPlayingCapture?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onProgress?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onProgressCapture?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onRateChange?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onRateChangeCapture?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onSeeked?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onSeekedCapture?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onSeeking?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onSeekingCapture?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onStalled?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onStalledCapture?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onSuspend?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onSuspendCapture?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onTimeUpdate?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onTimeUpdateCapture?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onVolumeChange?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onVolumeChangeCapture?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onWaiting?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onWaitingCapture?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onAuxClick?: React__default.MouseEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onAuxClickCapture?: React__default.MouseEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onClick?: React__default.MouseEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onClickCapture?: React__default.MouseEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onContextMenu?: React__default.MouseEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onContextMenuCapture?: React__default.MouseEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onDoubleClick?: React__default.MouseEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onDoubleClickCapture?: React__default.MouseEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onDrag?: React__default.DragEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onDragCapture?: React__default.DragEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onDragEnd?: React__default.DragEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onDragEndCapture?: React__default.DragEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onDragEnter?: React__default.DragEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onDragEnterCapture?: React__default.DragEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onDragExit?: React__default.DragEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onDragExitCapture?: React__default.DragEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onDragLeave?: React__default.DragEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onDragLeaveCapture?: React__default.DragEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onDragOver?: React__default.DragEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onDragOverCapture?: React__default.DragEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onDragStart?: React__default.DragEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onDragStartCapture?: React__default.DragEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onDrop?: React__default.DragEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onDropCapture?: React__default.DragEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onMouseDown?: React__default.MouseEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onMouseDownCapture?: React__default.MouseEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onMouseEnter?: React__default.MouseEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onMouseLeave?: React__default.MouseEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onMouseMove?: React__default.MouseEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onMouseMoveCapture?: React__default.MouseEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onMouseOut?: React__default.MouseEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onMouseOutCapture?: React__default.MouseEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onMouseOver?: React__default.MouseEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onMouseOverCapture?: React__default.MouseEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onMouseUp?: React__default.MouseEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onMouseUpCapture?: React__default.MouseEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onSelect?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onSelectCapture?: React__default.ReactEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onTouchCancel?: React__default.TouchEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onTouchCancelCapture?: React__default.TouchEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onTouchEnd?: React__default.TouchEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onTouchEndCapture?: React__default.TouchEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onTouchMove?: React__default.TouchEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onTouchMoveCapture?: React__default.TouchEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onTouchStart?: React__default.TouchEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onTouchStartCapture?: React__default.TouchEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onPointerDown?: React__default.PointerEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onPointerDownCapture?: React__default.PointerEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onPointerMove?: React__default.PointerEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onPointerMoveCapture?: React__default.PointerEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onPointerUp?: React__default.PointerEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onPointerUpCapture?: React__default.PointerEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onPointerCancel?: React__default.PointerEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onPointerCancelCapture?: React__default.PointerEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onPointerEnter?: React__default.PointerEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onPointerLeave?: React__default.PointerEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onPointerOver?: React__default.PointerEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onPointerOverCapture?: React__default.PointerEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onPointerOut?: React__default.PointerEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onPointerOutCapture?: React__default.PointerEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onGotPointerCapture?: React__default.PointerEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onGotPointerCaptureCapture?: React__default.PointerEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onLostPointerCapture?: React__default.PointerEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onLostPointerCaptureCapture?: React__default.PointerEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onScroll?: React__default.UIEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onScrollCapture?: React__default.UIEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onScrollEnd?: React__default.UIEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onScrollEndCapture?: React__default.UIEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onWheel?: React__default.WheelEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onWheelCapture?: React__default.WheelEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onAnimationStart?: React__default.AnimationEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onAnimationStartCapture?: React__default.AnimationEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onAnimationEnd?: React__default.AnimationEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onAnimationEndCapture?: React__default.AnimationEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onAnimationIteration?: React__default.AnimationEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onAnimationIterationCapture?: React__default.AnimationEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onToggle?: React__default.ToggleEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onBeforeToggle?: React__default.ToggleEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onTransitionCancel?: React__default.TransitionEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onTransitionCancelCapture?: React__default.TransitionEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onTransitionEnd?: React__default.TransitionEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onTransitionEndCapture?: React__default.TransitionEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onTransitionRun?: React__default.TransitionEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onTransitionRunCapture?: React__default.TransitionEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onTransitionStart?: React__default.TransitionEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    onTransitionStartCapture?: React__default.TransitionEventHandler<HTMLElement | HTMLLabelElement> | undefined;
+    ref?: React__default.RefObject<HTMLElement>;
+}, HTMLElement>;
+
+type MenuProps = ModalProps & {
+    children: React__default.ReactNode;
+    contentClassName?: string;
+    contentStyle?: React__default.CSSProperties;
+    menuContentRef?: RefObject<HTMLUListElement>;
+};
+declare const Menu: {
+    ({ children, isOpen, onClose, id, menuContentRef, contentClassName, contentStyle, className, ...modalProps }: MenuProps): react_jsx_runtime.JSX.Element;
+    Option: ({ children, label, asCheckbox, icon: Icon, id, disabled, selected, className, style, onClick, ...liProps }: MenuOptionProps) => react_jsx_runtime.JSX.Element;
+    Divider: () => react_jsx_runtime.JSX.Element;
+    GroupLabel: ({ children, className, ...props }: Omit<TypographyProps, "variant">) => react_jsx_runtime.JSX.Element;
+    Group: ({ children, label, className, style, contentClassName, contentStyle, ...props }: MenuGroupProps) => react_jsx_runtime.JSX.Element;
+};
+type MenuOptionProps = Omit<React__default.HTMLAttributes<HTMLLIElement>, 'onClick'> & {
+    id?: string;
+    children?: React__default.ReactNode;
+    label?: React__default.ReactNode;
+    disabled?: boolean;
+    selected?: boolean;
+    className?: string;
+    style?: React__default.CSSProperties;
+    asCheckbox?: boolean;
+    icon?: IconType;
+    onClick?: (newValue: boolean) => void;
+};
+type MenuGroupProps = Omit<React__default.HTMLAttributes<HTMLLIElement>, 'onClick'> & {
+    children: React__default.ReactNode;
+    label: React__default.ReactNode;
+    className?: string;
+    style?: React__default.CSSProperties;
+    contentClassName?: string;
+    contentStyle?: React__default.CSSProperties;
+};
+
+type PortalProps = {
+    id: string;
+    children: ReactNode;
+};
+declare const Portal: ({ children, id }: PortalProps) => React$1.ReactPortal | null;
+
+interface RippleProps {
+    color?: string;
+    duration?: number;
+    timingFunction?: React__default.CSSProperties['animationTimingFunction'];
+    times?: number;
+    className?: string;
+    style?: React__default.CSSProperties;
+    zIndex?: React__default.CSSProperties['zIndex'];
+}
+declare const Ripple: ({ color, duration, timingFunction, times, className, style, zIndex, }: RippleProps) => react_jsx_runtime.JSX.Element;
+
+type Primitive = string | number | boolean;
+type RowDataObject = {
+    [key: string]: Primitive | object;
+};
+type Order = 'asc' | 'desc';
+type ColumnDataCommon<RowData extends RowDataObject> = {
+    header: React__default.ReactNode;
+    sortBy?: KeyValuesOf<RowData, Primitive> | null;
+    icon?: IconType;
+    width?: `${number}px` | `${number}em` | `${number}%`;
+    hidden?: boolean;
+};
+type ColumnDataField<RowData extends RowDataObject> = ColumnDataCommon<RowData> & {
+    field: KeyValuesOf<RowData, Primitive>;
+    sortBy?: null;
+    render?: never;
+    Component?: never;
+};
+type ColumnDataRender<RowData extends RowDataObject> = ColumnDataCommon<RowData> & {
+    field?: never;
+    render: (row: RowData, rowKey: React__default.Key) => React__default.ReactNode;
+    Component?: never;
+};
+type ColumnDataComponent<RowData extends RowDataObject> = ColumnDataCommon<RowData> & {
+    field?: never;
+    render?: never;
+    Component: React__default.FC<{
+        data: RowData;
+        rowKey: React__default.Key;
+    }>;
+};
+type ColumnData<RowData extends RowDataObject> = ColumnDataField<RowData> | ColumnDataRender<RowData> | ColumnDataComponent<RowData>;
+
+type SmartTableProps<RowData extends RowDataObject> = {
+    columns: Array<ColumnData<RowData>>;
+    data: Array<RowData>;
+    width?: 'scroll' | 'content';
+    selectable?: boolean;
+    rowId: KeyValuesOf<RowData, React.Key>;
+    className?: string;
+    tableClassName?: string;
+};
+declare const SmartTable: <RowData extends RowDataObject>({ columns: initialColumns, data, width, selectable, rowId, className, tableClassName: _tableClassName, }: SmartTableProps<RowData>) => react_jsx_runtime.JSX.Element;
+
+declare enum RadiusVariants {
+    None = "none",
+    Small = "small",
+    Medium = "medium",
+    Large = "large",
+    Full = "full"
+}
+declare enum SizeVariants {
+    Small = "small",
+    Medium = "medium",
+    Large = "large"
+}
+declare enum TabListVariant {
+    SOLID = "solid",
+    GHOST = "ghost",
+    FLAT = "flat",
+    LINE = "line"
+}
+declare enum TabListColor {
+    PRIMARY = "primary",
+    SECONDARY = "secondary",
+    TERTIARY = "tertiary"
+}
+declare enum TabListDirection {
+    HORIZONTAL = "horizontal",
+    VERTICAL = "vertical"
+}
+type TabListProps = {
+    openTab: string;
+    variant?: `${TabListVariant}`;
+    children?: React__default.ReactNode;
+    size?: `${SizeVariants}`;
+    color?: `${TabListColor}`;
+    radius?: `${RadiusVariants}`;
+    direction?: `${TabListDirection}`;
+    className?: string;
+    style?: React__default.CSSProperties;
+    tabs?: Array<{
+        id: string;
+        label: React__default.ReactNode;
+    }>;
+};
+
+type TabsProps = {
+    children: React__default.ReactNode;
+    defaultOpenTab: string;
+    onChange?: (id: string) => void;
+};
+declare const Tabs: {
+    ({ children, defaultOpenTab, onChange }: TabsProps): react_jsx_runtime.JSX.Element;
+    Tab: ({ id, children, className, style, onClick, ref }: TabProps) => react_jsx_runtime.JSX.Element;
+    TabPanel: ({ id, children }: TabPanelProps) => React__default.ReactNode;
+    TabList: ({ children, ...props }: Omit<TabListProps, "openTab">) => react_jsx_runtime.JSX.Element;
+};
+type TabProps = {
+    id: string;
+    children: React__default.ReactNode;
+    className?: string;
+    style?: React__default.CSSProperties;
+    onClick?: (e: React__default.MouseEvent<HTMLSpanElement>) => void;
+    ref?: React__default.RefObject<HTMLSpanElement | null>;
+};
+type TabPanelProps = {
+    id: string;
+    children: React__default.ReactNode;
+};
+
+declare enum TagRounded {
+    NONE = "none",
+    SMALL = "small",
+    MEDIUM = "medium",
+    LARGE = "large",
+    FULL = "full"
+}
+interface TagProps extends React.HTMLAttributes<HTMLSpanElement> {
+    children: React.ReactNode;
+    selected?: boolean;
+    rounded?: `${TagRounded}`;
+    noWrap?: boolean;
+    ref?: React.Ref<HTMLElement>;
+}
+declare const Tag: ({ children, rounded, selected, noWrap, ref }: TagProps) => react_jsx_runtime.JSX.Element;
+
+type TooltipProps = {
+    position?: `${PositionContainer.TOP}` | `${PositionContainer.LEFT}` | `${PositionContainer.RIGHT}` | `${PositionContainer.BOTTOM}`;
+    offset?: number | `${number}`;
+    disabled?: boolean;
+    children: React__default.ReactElement<{
+        ref: React__default.RefObject<HTMLElement | null>;
+    }>;
+    content: React__default.ReactNode;
+};
+declare const Tooltip: ({ position, children, content, offset, disabled, }: TooltipProps) => react_jsx_runtime.JSX.Element;
+
+type ClickToCopyProps = {
+    children?: React.ReactNode;
+    position?: TooltipProps['position'];
+    offset?: TooltipProps['offset'];
+    value: string;
+    tooltipText: string;
+    tooltipCopiedText?: string;
+    copiedTextTimeout?: number;
+};
+declare const ClickToCopy: ({ children, value, position, offset, tooltipText, tooltipCopiedText, copiedTextTimeout, }: ClickToCopyProps) => react_jsx_runtime.JSX.Element;
+
+export { Accordion, AccordionItem, ActionModal, type ActionModalProps, AsideModal, Backdrop, type BackdropProps, Button, type ButtonProps, Checkbox, ClickToCopy, type ColumnData, ConfirmationModal, Cursor, DatePicker, Field, FieldOrientation, type FieldProps, FieldVariant, FlipCard, HoverCard, Image, InfinityScroll, Input, InputColor, type InputFieldProps, InputFile, InputNumber, InputPassword, Line, LineOrientation, LineStyle, Menu, type MenuOptionProps, Modal, ModalBackdrop, type ModalProps, type Order, Portal, type Primitive, Radio, Ripple, type RowDataObject, Select, SlideCard, Slider, SmartTable, Switch, Tabs, Tag, TagRounded, Textarea, Tooltip, type TooltipProps, Typography, type TypographyProps, useAccordionItem };