@tanishraj/ui-kit 2.5.2 → 2.5.3

package/dist/index.d.ts

@@ -1,5 +1,4 @@
 import { ActionMeta } from 'react-select';
-import { AnchorHTMLAttributes } from 'react';
 import { AsyncCreatableProps } from 'react-select/async-creatable';
 import { AsyncProps } from 'react-select/async';
 import { ClassProp } from 'class-variance-authority/types';
@@ -7,7 +6,9 @@ import { ClassValue } from 'clsx';
 import { ComponentProps } from 'react';
 import { ComponentPropsWithoutRef } from 'react';
 import { ComponentPropsWithRef } from 'react';
+import { ComponentType } from 'react';
 import { CreatableProps } from 'react-select/creatable';
+import { DayPickerProps } from 'react-day-picker';
 import { default as default_2 } from 'react-select';
 import { DetailedHTMLProps } from 'react';
 import { FC } from 'react';
@@ -15,13 +16,14 @@ import { FieldsetHTMLAttributes } from 'react';
 import { ForwardRefExoticComponent } from 'react';
 import { GroupBase } from 'react-select';
 import { HTMLAttributes } from 'react';
-import { HTMLProps } from 'react';
 import { ITooltip } from 'react-tooltip';
 import { JSX } from 'react';
+import { JSXElementConstructor } from 'react';
 import { Key } from 'react';
 import { KeyboardEvent as KeyboardEvent_2 } from 'react';
 import { LabelHTMLAttributes } from 'react';
 import { MouseEvent as MouseEvent_2 } from 'react';
+import { MouseEventHandler } from 'react';
 import { MultiValue } from 'react-select';
 import { Options } from 'react-select';
 import { Placement } from '@floating-ui/react';
@@ -62,15 +64,18 @@ export declare type AccordionSizes = RemoveNull<VariantProps<typeof accordionRoo
 
 export declare type AccordionType = 'single' | 'multiple';
 
-export declare const Alert: FC<AlertProps>;
+export declare function Alert({ variant, appearance, size, inverted, title, icon: Icon, children, onClose, closeLabel, className, role, ...restProps }: AlertProps): JSX.Element;
 
 export declare type AlertAppearances = RemoveNull<VariantProps<typeof alertWrapperStyles>>['appearance'];
 
-export declare interface AlertProps extends RemoveNull<VariantProps<typeof alertWrapperStyles>> {
-    title?: string;
-    icon?: FC<SVGProps<SVGSVGElement>>;
+declare type AlertIcon = ComponentType<SVGProps<SVGSVGElement>>;
+
+export declare interface AlertProps extends Omit<ComponentPropsWithoutRef<'div'>, 'title'>, RemoveNull<VariantProps<typeof alertWrapperStyles>> {
+    title?: ReactNode;
+    icon?: AlertIcon;
     children?: ReactNode;
     onClose?: () => void;
+    closeLabel?: string;
 }
 
 export declare type AlertSizes = RemoveNull<VariantProps<typeof alertWrapperStyles>>['size'];
@@ -84,23 +89,24 @@ declare const alertWrapperStyles: (props?: ({
     inverted?: boolean | null | undefined;
 } & ClassProp) | undefined) => string;
 
-export declare const AnimatePresence: FC<AnimatePresenceProps>;
+export declare function AnimatePresence({ children, presence }: AnimatePresenceProps): JSX.Element | null;
 
-export declare const AnimatePresenceChild: FC<PresenceChildProps>;
+export declare function AnimatePresenceChild({ children }: PresenceChildProps): ReactElement<unknown, string | JSXElementConstructor<any>>;
 
 declare interface AnimatePresenceProps {
     children: ReactElement | ReactElement[];
     presence: boolean;
 }
 
-export declare const AsyncSelect: <Option extends SelectOption = SelectOption, IsMulti extends boolean = false>({ ref, id, label, caption, error, errorMsg, hideErrorMsg, hintText, size, variant, fullWidth, containerClassName, labelClassName, inputClassName, disabled, isDisabled, readOnly, readonly, required, isCreatable, createText, placeholder, className, classNames: customClassNames, components: customComponents, controlShouldRenderValue, defaultOptions, formatCreateLabel, formatOptionLabel, getOptionLabel, getOptionValue, inputValue, isMulti, isOptionDisabled, isSearchable, loadOptions, menuIsOpen, menuPlacement, menuPortalTarget, menuPosition, onBlur, onFocus, onMenuClose, onMenuOpen, options, openMenuOnClick, styles: customStyles, ...restProps }: AsyncSelectProps<Option, IsMulti>) => JSX.Element;
+export declare const AsyncSelect: <Option extends SelectOption = SelectOption, IsMulti extends boolean = false>({ ref, id, label, caption, error, errorMsg, hideErrorMsg, hintText, size, variant, fullWidth, containerClassName, labelClassName, inputClassName, disabled, isDisabled, readOnly, readonly, required, isCreatable, createText, placeholder, className, classNames: customClassNames, components: customComponents, controlShouldRenderValue, defaultOptions, formatCreateLabel, formatOptionLabel, getOptionLabel, getOptionValue, inputValue, isMulti, isOptionDisabled, isSearchable, loadOptions, menuIsOpen, menuPlacement, menuPortalTarget, menuPosition, onBlur, onFocus, onMenuClose, onMenuOpen, options, openMenuOnClick, styles: customStyles, "aria-describedby": ariaDescribedBy, "aria-invalid": ariaInvalid, ...restProps }: AsyncSelectProps<Option, IsMulti>) => JSX.Element;
 
 export declare interface AsyncSelectProps<Option extends SelectOption = SelectOption, IsMulti extends boolean = false> extends Omit<AsyncProps<Option, IsMulti, GroupBase<Option>>, 'size' | 'isDisabled'>, Omit<AsyncCreatableProps<Option, IsMulti, GroupBase<Option>>, 'size' | 'isDisabled'>, Pick<SelectProps<Option, IsMulti>, 'caption' | 'containerClassName' | 'createText' | 'disabled' | 'error' | 'errorMsg' | 'fullWidth' | 'hideErrorMsg' | 'hintText' | 'inputClassName' | 'isCreatable' | 'label' | 'labelClassName' | 'readOnly' | 'readonly' | 'ref' | 'required' | 'size' | 'variant'> {
+    'aria-describedby'?: string;
     isDisabled?: boolean;
     options?: Options<Option>;
 }
 
-export declare const Avatar: FC<AvatarProps>;
+export declare function Avatar({ icon: Icon, img, initials, status, statusPosition, size, shape, variant, inverted, stroke, className, role, ...restProps }: AvatarProps): JSX.Element;
 
 declare const avatarContainerStyles: (props?: ({
     size?: "sm" | "md" | "lg" | "xs" | null | undefined;
@@ -110,11 +116,11 @@ declare const avatarContainerStyles: (props?: ({
     stroke?: boolean | null | undefined;
 } & ClassProp) | undefined) => string;
 
-export declare const AvatarGroup: FC<AvatarGroupProps>;
+export declare function AvatarGroup({ items, size, variant, shape, max, inverted, stroke, className, role, ...restProps }: AvatarGroupProps): JSX.Element;
 
 export declare type AvatarGroupItem = Omit<AvatarProps, 'size' | 'shape' | 'inverted' | 'stroke' | 'className'>;
 
-export declare interface AvatarGroupProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+export declare interface AvatarGroupProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children'> {
     items?: AvatarGroupItem[];
     size?: AvatarGroupSizes;
     variant?: AvatarVariants;
@@ -128,14 +134,14 @@ export declare type AvatarGroupShapes = RemoveNull<VariantProps<typeof avatarCon
 
 export declare type AvatarGroupSizes = RemoveNull<VariantProps<typeof avatarContainerStyles>>['size'];
 
-export declare type AvatarIcon = FC<SVGProps<SVGSVGElement>>;
+export declare type AvatarIcon = ComponentType<SVGProps<SVGSVGElement>>;
 
 export declare type AvatarImage = {
     src: string;
     alt: string;
 };
 
-export declare interface AvatarProps extends HTMLAttributes<HTMLSpanElement>, Omit<VariantProps<typeof avatarContainerStyles>, 'stroke'> {
+export declare interface AvatarProps extends ComponentPropsWithoutRef<'span'>, Omit<VariantProps<typeof avatarContainerStyles>, 'stroke'> {
     icon?: AvatarIcon;
     img?: AvatarImage;
     initials?: string;
@@ -165,12 +171,12 @@ declare const avatarStatusStyles: (props?: ({
 
 export declare type AvatarVariants = RemoveNull<VariantProps<typeof avatarContainerStyles>>['variant'];
 
-export declare const Badge: FC<BadgeProps>;
+export declare function Badge({ variant, size, shape, inverted, icon: Icon, children, role, className, ...restProps }: BadgeProps): JSX.Element;
 
 export declare type BadgeAppearances = RemoveNull<VariantProps<typeof badgeVariants>>['appearance'];
 
-export declare interface BadgeProps extends HTMLAttributes<HTMLSpanElement>, Omit<VariantProps<typeof badgeVariants>, 'appearance'> {
-    icon?: FC<SVGProps<SVGSVGElement>>;
+export declare interface BadgeProps extends ComponentPropsWithoutRef<'span'>, Omit<VariantProps<typeof badgeVariants>, 'appearance'> {
+    icon?: ComponentType<SVGProps<SVGSVGElement>>;
 }
 
 export declare type BadgeShapes = RemoveNull<VariantProps<typeof badgeVariants>>['shape'];
@@ -181,26 +187,40 @@ export declare type BadgeVariants = RemoveNull<VariantProps<typeof badgeVariants
 
 declare const badgeVariants: (props?: ({
     variant?: "default" | "primary" | "info" | "success" | "warning" | "danger" | null | undefined;
-    appearance?: "icon" | "text" | "dots" | null | undefined;
+    appearance?: "text" | "icon" | "dots" | null | undefined;
     size?: "sm" | "md" | "lg" | null | undefined;
     shape?: "circle" | "square" | null | undefined;
     inverted?: boolean | null | undefined;
     hasIcon?: boolean | null | undefined;
 } & ClassProp) | undefined) => string;
 
-export declare const Breadcrumb: FC<BreadcrumbProps>;
+declare type BaseDatePickerProps = Omit<InputProps, 'defaultValue' | 'leadingIcon' | 'onChange' | 'onClear' | 'readOnly' | 'trailingIcon' | 'type' | 'value'> & {
+    calendarProps?: DatePickerCalendarProps | undefined;
+    closeOnSelect?: boolean;
+    defaultOpen?: boolean;
+    defaultValue?: Date | undefined;
+    formatDate?: (date: Date) => string;
+    onClear?: () => void;
+    onOpenChange?: (open: boolean) => void;
+    onValueChange?: (value: Date | undefined) => void;
+    open?: boolean;
+    panelClassName?: string;
+    value?: Date | undefined;
+};
+
+export declare function Breadcrumb({ items, appearance, separator, role, className, ...restProps }: BreadcrumbProps): JSX.Element;
 
 export declare type BreadcrumbAppearances = RemoveNull<VariantProps<typeof breadcrumbStyles>>['appearance'];
 
-export declare interface BreadcrumbItem extends Omit<AnchorHTMLAttributes<HTMLAnchorElement>, 'children'> {
+export declare interface BreadcrumbItem extends Omit<ComponentPropsWithoutRef<'a'>, 'children'> {
     id?: string;
     label: ReactNode;
-    icon?: FC<SVGProps<SVGSVGElement>>;
+    icon?: ComponentType<SVGProps<SVGSVGElement>>;
     current?: boolean;
     disabled?: boolean;
 }
 
-export declare interface BreadcrumbProps extends HTMLAttributes<HTMLElement> {
+export declare interface BreadcrumbProps extends ComponentPropsWithoutRef<'nav'> {
     items: BreadcrumbItem[];
     appearance?: BreadcrumbAppearances;
     separator?: BreadcrumbSeparators;
@@ -212,11 +232,11 @@ declare const breadcrumbStyles: (props?: ({
     appearance?: "outline" | "ghost" | null | undefined;
 } & ClassProp) | undefined) => string;
 
-export declare const Button: FC<ButtonProps>;
+export declare function Button({ ref, size, variant, appearance, shape, disabled, loading, fullWidth, inverted, children, type, leadingIcon: LeadingIcon, trailingIcon: TrailingIcon, className, ...restProps }: ButtonProps): JSX.Element;
 
 export declare type ButtonAppearances = RemoveNull<VariantProps<typeof buttonStyles>>['appearance'];
 
-export declare const ButtonGroup: FC<ButtonGroupProps>;
+export declare function ButtonGroup({ buttons, orientation, size, inverted, role, className, ...restProps }: ButtonGroupProps): JSX.Element;
 
 export declare interface ButtonGroupItem extends Omit<ButtonProps, 'children' | 'ref' | 'className'> {
     children?: ReactNode;
@@ -225,20 +245,21 @@ export declare interface ButtonGroupItem extends Omit<ButtonProps, 'children' |
 
 export declare type ButtonGroupOrientation = 'horizontal' | 'vertical';
 
-export declare interface ButtonGroupProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children' | 'className'> {
+export declare interface ButtonGroupProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children'> {
     buttons?: ButtonGroupItem[];
     orientation?: ButtonGroupOrientation;
     size?: ButtonGroupSizes;
     inverted?: boolean;
-    role?: 'group' | string;
 }
 
 export declare type ButtonGroupSizes = ButtonSizes;
 
+declare type ButtonIcon = ComponentType<SVGProps<SVGSVGElement>>;
+
 export declare interface ButtonProps extends ComponentPropsWithRef<'button'>, RemoveNull<Omit<VariantProps<typeof buttonStyles>, 'disabled'>> {
-    children: ReactNode;
-    leadingIcon?: FC<SVGProps<SVGSVGElement>>;
-    trailingIcon?: FC<SVGProps<SVGSVGElement>>;
+    children?: ReactNode;
+    leadingIcon?: ButtonIcon;
+    trailingIcon?: ButtonIcon;
 }
 
 export declare type ButtonShapes = RemoveNull<VariantProps<typeof buttonStyles>>['shape'];
@@ -253,23 +274,33 @@ declare const buttonStyles: (props?: ({
     disabled?: boolean | null | undefined;
     loading?: boolean | null | undefined;
     fullWidth?: boolean | null | undefined;
+    iconOnly?: boolean | null | undefined;
     inverted?: boolean | null | undefined;
 } & ClassProp) | undefined) => string;
 
 export declare type ButtonVariants = RemoveNull<VariantProps<typeof buttonStyles>>['variant'];
 
-export declare const Checkbox: FC<CheckboxProps>;
+export declare function Calendar({ className, classNames, components, shape, showOutsideDays, ...props }: CalendarProps): JSX.Element;
+
+export declare type CalendarProps = DistributiveOmit<DayPickerProps, 'navLayout'> & {
+    shape?: CalendarShape;
+};
+
+export declare type CalendarShape = 'squared' | 'circle';
+
+export declare function Checkbox({ ref, id, label, description, error, size, shape, indeterminate, disabled, required, checked, defaultChecked, className, onChange, onClick, ...restProps }: CheckboxProps): JSX.Element;
 
 declare const checkboxControlStyles: (props?: ({
     size?: "sm" | "md" | "lg" | null | undefined;
     shape?: "circle" | "square" | null | undefined;
+    hasHelperText?: boolean | null | undefined;
     invalid?: boolean | null | undefined;
     indeterminate?: boolean | null | undefined;
 } & ClassProp) | undefined) => string;
 
-export declare const CheckboxGroup: FC<CheckboxGroupProps>;
+export declare function CheckboxGroup({ options, value, defaultValue, onValueChange, name, label, description, error, size, shape, orientation, disabled, required, className, ...restProps }: CheckboxGroupProps): JSX.Element;
 
-export declare interface CheckboxGroupOption extends Omit<CheckboxProps, 'checked' | 'defaultChecked' | 'children' | 'error' | 'name' | 'ref' | 'size' | 'type' | 'value'> {
+export declare interface CheckboxGroupOption extends Omit<CheckboxProps, 'checked' | 'description' | 'defaultChecked' | 'children' | 'error' | 'name' | 'ref' | 'size' | 'type' | 'value'> {
     value: string;
 }
 
@@ -303,7 +334,7 @@ export declare interface CheckboxProps extends Omit<ComponentPropsWithRef<'input
     indeterminate?: boolean;
 }
 
-export declare const CheckboxSelect: <Option extends SelectOption = SelectOption, IsMulti extends boolean = false>({ ref, id, label, caption, error, errorMsg, hideErrorMsg, hintText, size, variant, fullWidth, containerClassName, labelClassName, inputClassName, disabled, isDisabled, readOnly, readonly, required, placeholder, className, classNames: customClassNames, components: customComponents, compactDisplay, formatOptionLabel, getOptionLabel, getOptionValue, isMulti, isOptionDisabled, isSearchable, menuIsOpen, menuPlacement, menuPortalTarget, menuPosition, openMenuOnClick, options, styles: customStyles, value, ...restProps }: CheckboxSelectProps<Option, IsMulti>) => JSX.Element;
+export declare const CheckboxSelect: <Option extends SelectOption = SelectOption, IsMulti extends boolean = false>({ ref, id, label, caption, error, errorMsg, hideErrorMsg, hintText, size, variant, fullWidth, containerClassName, labelClassName, inputClassName, disabled, isDisabled, readOnly, readonly, required, placeholder, className, classNames: customClassNames, components: customComponents, compactDisplay, formatOptionLabel, getOptionLabel, getOptionValue, isMulti, isOptionDisabled, isSearchable, menuIsOpen, menuPlacement, menuPortalTarget, menuPosition, openMenuOnClick, options, styles: customStyles, value, "aria-describedby": ariaDescribedBy, "aria-invalid": ariaInvalid, ...restProps }: CheckboxSelectProps<Option, IsMulti>) => JSX.Element;
 
 export declare interface CheckboxSelectProps<Option extends SelectOption = SelectOption, IsMulti extends boolean = false> extends SelectProps<Option, IsMulti> {
     compactDisplay?: boolean;
@@ -313,9 +344,9 @@ export declare type CheckboxShapes = RemoveNull<VariantProps<typeof checkboxCont
 
 export declare type CheckboxSizes = RemoveNull<VariantProps<typeof checkboxControlStyles>>['size'];
 
-export declare const Chip: FC<ChipProps>;
+export declare function Chip({ children, icon: Icon, variant, appearance, size, shape, inverted, disabled, onClose, closeLabel, className, ...restProps }: ChipProps): JSX.Element;
 
-export declare type ChipIcon = FC<SVGProps<SVGSVGElement>>;
+export declare type ChipIcon = ComponentType<SVGProps<SVGSVGElement>>;
 
 export declare interface ChipProps extends Omit<ComponentPropsWithoutRef<'span'>, 'children'>, RemoveNull<Omit<VariantProps<typeof chipStyles>, 'disabled' | 'hasLeadingVisual' | 'removable'>> {
     children: string | number;
@@ -357,11 +388,11 @@ export declare interface CompactListProps<T extends ItemType> {
     renderItem?: (item: T, index: number) => ReactNode;
 }
 
-export declare const ConfirmationPopup: FC<ConfirmationPopupProps>;
+export declare function ConfirmationPopup({ trigger, title, description, children, open, defaultOpen, onOpenChange, onClose, onCancel, onAction, placement, align, size, variant, closeLabel, cancelLabel, actionLabel, closeOnEscape, closeOnOutsideClick, closeOnCancel, closeOnAction, portalled, showArrow, showCloseButton, showCancelButton, showActionButton, leadingIcon, className, contentClassName, triggerClassName, actionButtonProps, cancelButtonProps, ...restProps }: ConfirmationPopupProps): JSX.Element;
 
 export declare type ConfirmationPopupAlignments = 'start' | 'center' | 'end';
 
-export declare type ConfirmationPopupIcon = FC<SVGProps<SVGSVGElement>>;
+export declare type ConfirmationPopupIcon = ComponentType<SVGProps<SVGSVGElement>>;
 
 declare const confirmationPopupIconStyles: (props?: ({
     size?: "sm" | "md" | "lg" | null | undefined;
@@ -374,7 +405,7 @@ declare const confirmationPopupPanelStyles: (props?: ({
 
 export declare type ConfirmationPopupPlacements = 'top' | 'right' | 'bottom' | 'left';
 
-export declare interface ConfirmationPopupProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children' | 'onCancel' | 'title'>, RemoveNull<VariantProps<typeof confirmationPopupIconStyles>>, RemoveNull<VariantProps<typeof confirmationPopupPanelStyles>> {
+export declare interface ConfirmationPopupProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children' | 'onCancel' | 'title'>, RemoveNull<VariantProps<typeof confirmationPopupIconStyles>>, RemoveNull<VariantProps<typeof confirmationPopupPanelStyles>> {
     trigger?: ReactNode;
     title?: ReactNode;
     description?: ReactNode;
@@ -394,6 +425,7 @@ export declare interface ConfirmationPopupProps extends Omit<HTMLAttributes<HTML
     closeOnOutsideClick?: boolean;
     closeOnCancel?: boolean;
     closeOnAction?: boolean;
+    portalled?: boolean;
     showArrow?: boolean;
     showCloseButton?: boolean;
     showCancelButton?: boolean;
@@ -409,7 +441,7 @@ export declare type ConfirmationPopupSizes = RemoveNull<VariantProps<typeof conf
 
 export declare type ConfirmationPopupVariants = RemoveNull<VariantProps<typeof confirmationPopupIconStyles>>['variant'];
 
-export declare const CountryFlag: FC<CountryFlagProps>;
+export declare function CountryFlag({ code, name, size, className, loading, decoding, ...restProps }: CountryFlagProps): JSX.Element | null;
 
 export declare interface CountryFlagProps extends Omit<ComponentPropsWithoutRef<'img'>, 'alt' | 'height' | 'src' | 'width'> {
     code?: string;
@@ -419,11 +451,19 @@ export declare interface CountryFlagProps extends Omit<ComponentPropsWithoutRef<
 
 export declare type CountryFlagSize = 'xs' | 'sm' | 'md' | 'lg';
 
-export declare const Divider: FC<DividerProps>;
+export declare function DatePicker(props: DatePickerProps): JSX.Element;
+
+export declare type DatePickerCalendarProps = Omit<CalendarProps, 'mode' | 'selected' | 'onSelect'>;
+
+export declare type DatePickerProps = Readonly<BaseDatePickerProps>;
+
+declare type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
+
+export declare function Divider({ children, orientation, className, role, ...restProps }: DividerProps): JSX.Element;
 
 export declare type DividerOrientations = RemoveNull<VariantProps<typeof dividerRootStyles>>['orientation'];
 
-export declare interface DividerProps extends HTMLAttributes<HTMLDivElement> {
+export declare interface DividerProps extends ComponentPropsWithoutRef<'div'> {
     children?: ReactNode;
     orientation?: DividerOrientations;
 }
@@ -433,7 +473,7 @@ declare const dividerRootStyles: (props?: ({
     hasContent?: boolean | null | undefined;
 } & ClassProp) | undefined) => string;
 
-export declare const Drawer: FC<DrawerProps>;
+export declare function Drawer({ open, children, title, description, footer, onClose, placement, size, closeLabel, closeOnEscape, closeOnOverlayClick, container, containerId, containerRef, disablePortal, showCloseButton, showOverlay, role, className, ...restProps }: DrawerProps): JSX.Element;
 
 declare const drawerPanelStyles: (props?: ({
     placement?: "top" | "right" | "bottom" | "left" | null | undefined;
@@ -442,7 +482,7 @@ declare const drawerPanelStyles: (props?: ({
 
 export declare type DrawerPlacements = RemoveNull<VariantProps<typeof drawerPanelStyles>>['placement'];
 
-export declare interface DrawerProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'>, RemoveNull<VariantProps<typeof drawerPanelStyles>> {
+export declare interface DrawerProps extends Omit<ComponentPropsWithoutRef<'div'>, 'title'>, RemoveNull<VariantProps<typeof drawerPanelStyles>> {
     open: boolean;
     children?: ReactNode;
     title?: ReactNode;
@@ -462,7 +502,7 @@ export declare interface DrawerProps extends Omit<HTMLAttributes<HTMLDivElement>
 
 export declare type DrawerSizes = RemoveNull<VariantProps<typeof drawerPanelStyles>>['size'];
 
-export declare const Dropdown: FC<DropdownProps>;
+export declare function Dropdown({ children, chevronIcon: ChevronIcon, clickOutsideToClose, closeOnSelect, defaultOpen, icon: Icon, iconOnly, inline, items, align, menuClassName, menuContent, menuOffset, menuPlacement, menuProps, onItemSelect, onOpenChange, open, placement, portalTarget, renderAs, selectedValue, showChevron, trigger, triggerAction, triggerClassName, usePortal, withArrow, leadingIcon, type, 'aria-label': ariaLabel, 'aria-haspopup': ariaHasPopup, className, disabled, loading, onClick, ...restProps }: DropdownProps): JSX.Element;
 
 export declare type DropdownAlignments = 'start' | 'center' | 'end';
 
@@ -513,6 +553,32 @@ export declare type DropdownTriggerAction = 'click' | 'hover';
 
 export declare type DropdownVariants = ButtonVariants;
 
+export declare function EmptyState({ title, description, icon, size, orientation, actions, copyClassName, children, className, ...props }: Readonly<EmptyStateProps>): JSX.Element;
+
+export declare type EmptyStateAction = Readonly<Omit<ButtonProps, 'ref' | 'size'> & {
+    actionKey?: Key;
+    size?: ButtonProps['size'];
+}>;
+
+export declare type EmptyStateOrientation = RemoveNull<VariantProps<typeof emptyStateRootStyles>>['orientation'];
+
+export declare interface EmptyStateProps extends Omit<ComponentPropsWithRef<'div'>, 'title'> {
+    actions?: ReadonlyArray<EmptyStateAction>;
+    copyClassName?: string;
+    description?: ReactNode;
+    icon?: ReactNode;
+    orientation?: EmptyStateOrientation;
+    size?: EmptyStateSize;
+    title?: ReactNode;
+}
+
+declare const emptyStateRootStyles: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+    orientation?: "horizontal" | "vertical" | null | undefined;
+} & ClassProp) | undefined) => string;
+
+export declare type EmptyStateSize = RemoveNull<VariantProps<typeof emptyStateRootStyles>>['size'];
+
 declare enum EThemeOptions {
     LIGHT = "light",
     DARK = "dark"
@@ -524,7 +590,7 @@ export declare enum ETrend {
     neutral = "neutral"
 }
 
-export declare const Feedback: FC<FeedbackProps>;
+export declare function Feedback({ ref, className, defaultValue, disabled, getLabelText, name, onValueChange, options, readOnly, size, value, variant, 'aria-label': ariaLabel, ...restProps }: FeedbackProps): JSX.Element;
 
 export declare type FeedbackGetLabelText = (option: FeedbackOption, index: number, total: number) => string;
 
@@ -569,7 +635,7 @@ export declare const getGrowthTrend: ({ currentValue, pastValue, isPercentage, h
 
 export declare const getTrendVariant: (value: number | null | undefined, customThreshold?: number) => ETrend;
 
-export declare const GroupedSelect: <Option extends GroupedSelectOption = GroupedSelectOption>({ caption, className, compactDisplay, containerClassName, disabled, error, errorMsg, fullWidth, hideErrorMsg, hideSelectedOptions, hintText, inputClassName, isClearable, isSearchable, label, labelClassName, menuIsOpen, menuPlacement, menuPortalTarget, menuPosition, onChange, options, placeholder, readOnly, readonly, ref, required, size, styles, value, variant, }: GroupedSelectProps<Option>) => JSX.Element;
+export declare const GroupedSelect: <Option extends GroupedSelectOption = GroupedSelectOption>({ caption, className, compactDisplay, containerClassName, disabled, error, errorMsg, fullWidth, hideErrorMsg, hideSelectedOptions, hintText, inputClassName, isClearable, isSearchable, label, labelClassName, menuIsOpen, menuPlacement, menuPortalTarget, menuPosition, onChange, options, placeholder, readOnly, readonly, ref, required, size, styles, value, variant, "aria-describedby": ariaDescribedBy, "aria-invalid": ariaInvalid, }: GroupedSelectProps<Option>) => JSX.Element;
 
 export declare interface GroupedSelectOption<T = string | number> extends SelectOption<T> {
     group: string;
@@ -601,51 +667,29 @@ export declare interface GroupedSelectProps<Option extends GroupedSelectOption =
     placeholder?: ReactNode;
     readOnly?: boolean;
     readonly?: boolean;
-    ref?: Ref<unknown>;
+    ref?: Ref<SelectInstance<Option, true, GroupBase<Option>>>;
     required?: boolean;
     size?: SelectSizes;
     styles?: ComponentProps<typeof default_2<Option, true>>['styles'];
     value?: MultiValue<Option>;
     variant?: SelectVariants;
+    'aria-describedby'?: string;
+    'aria-invalid'?: SelectAriaInvalid;
 }
 
 export declare type ILabelProps = LabelProps;
 
-export declare interface IMetricCardProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
-    hint?: IMetricHint;
-    items?: IMetricValueItem[];
-    label?: ILabelProps;
-    showDivider?: boolean;
-    value?: IMetricValue;
-}
-
-export declare interface IMetricHint {
-    color?: TMetricCardColorVariant;
-    text?: ReactNode;
-    trend?: ETrend;
-    trendInverted?: boolean;
-    trendPosition?: TTrendPosition;
-}
+export declare type IMetricCardProps = MetricCardProps;
 
-export declare interface IMetricValue {
-    color?: TMetricCardColorVariant;
-    supportText?: ReactNode;
-    supportTextSize?: TValueSupportSize;
-    text?: ReactNode;
-    trend?: ETrend;
-    trendInverted?: boolean;
-}
+export declare type IMetricHint = MetricHint;
 
-export declare interface IMetricValueItem {
-    hint?: IMetricHint;
-    value?: IMetricValue;
-}
+export declare type IMetricValue = MetricValue;
 
-export declare type IndicatorMapper = Record<ETrend, FC>;
+export declare type IMetricValueItem = MetricValueItemData;
 
-export declare const Input: FC<InputProps>;
+export declare function Input({ ref, id, label, caption, error, size, variant, fullWidth, leadingIcon: LeadingIcon, trailingIcon: TrailingIcon, clearable, clearLabel, containerClassName, labelClassName, inputClassName, className, fieldRef, disabled, required, value, defaultValue, onChange, onClear, onTrailingIconClick, trailingIconLabel, 'aria-describedby': ariaDescribedBy, 'aria-invalid': ariaInvalid, ...restProps }: InputProps): JSX.Element;
 
-export declare type InputIcon = FC<SVGProps<SVGSVGElement>>;
+export declare type InputIcon = ComponentType<SVGProps<SVGSVGElement>>;
 
 export declare interface InputProps extends Omit<ComponentPropsWithRef<'input'>, 'children' | 'prefix' | 'size'> {
     caption?: ReactNode;
@@ -653,14 +697,17 @@ export declare interface InputProps extends Omit<ComponentPropsWithRef<'input'>,
     clearable?: boolean;
     containerClassName?: string;
     error?: ReactNode;
+    fieldRef?: Ref<HTMLDivElement>;
     fullWidth?: boolean;
     inputClassName?: string;
     label?: ReactNode;
     labelClassName?: string;
     leadingIcon?: InputIcon;
     onClear?: () => void;
+    onTrailingIconClick?: MouseEventHandler<HTMLButtonElement>;
     size?: InputSizes;
     trailingIcon?: InputIcon;
+    trailingIconLabel?: string;
     variant?: InputVariants;
 }
 
@@ -684,9 +731,7 @@ export declare interface InternalTabProps extends TabProps {
 
 declare type ItemType = PrimitiveValue | ObjectItem;
 
-export declare type ITrendIndicatorProps = TrendIndicatorProps;
-
-export declare const Label: FC<LabelProps>;
+export declare function Label({ children, className, disabled, endAdornment, labelWeight, position, required, size, text, variant, ...restProps }: LabelProps): JSX.Element;
 
 export declare type LabelPosition = 'top' | 'bottom' | 'right' | 'left';
 
@@ -707,9 +752,9 @@ export declare type LabelVariant = 'primary' | 'secondary' | 'tertiary';
 
 export declare type LabelWeight = 'semibold' | 'medium' | 'normal';
 
-export declare const Link: FC<LinkProps>;
+export declare function Link({ ref, children, leadingIcon: LeadingIcon, trailingIcon: TrailingIcon, external, variant, size, underline, inverted, disabled, truncate, target, rel, href, className, onClick, ...restProps }: LinkProps): JSX.Element;
 
-export declare type LinkIcon = FC<SVGProps<SVGSVGElement>>;
+export declare type LinkIcon = ComponentType<SVGProps<SVGSVGElement>>;
 
 export declare interface LinkProps extends Omit<ComponentPropsWithRef<'a'>, 'children'>, RemoveNull<Omit<VariantProps<typeof linkStyles>, 'disabled' | 'truncate'>> {
     children: ReactNode;
@@ -737,7 +782,7 @@ export declare type LinkVariants = RemoveNull<VariantProps<typeof linkStyles>>['
 
 export declare const ListBox: ForwardRefExoticComponent<ListBoxProps & RefAttributes<HTMLDivElement>>;
 
-export declare type ListBoxIcon = FC<SVGProps<SVGSVGElement>>;
+export declare type ListBoxIcon = ComponentType<SVGProps<SVGSVGElement>>;
 
 export declare interface ListBoxItemData {
     disabled?: boolean;
@@ -747,16 +792,19 @@ export declare interface ListBoxItemData {
     value: string;
 }
 
-export declare interface ListBoxProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children'> {
+export declare interface ListBoxProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children' | 'role'> {
     children?: ReactNode;
-    itemRole?: 'option' | 'menuitem';
+    itemRole?: ListItemRole;
     items?: ListBoxItemData[];
     leadingSlot?: ReactNode;
     onItemSelect?: (item: ListBoxItemData) => void;
+    role?: ListBoxRole;
     selectedValue?: string;
     size?: ListBoxSizes;
 }
 
+export declare type ListBoxRole = 'listbox' | 'menu';
+
 export declare type ListBoxSizes = 'sm' | 'md' | 'lg';
 
 export declare const ListItem: ForwardRefExoticComponent<ListItemProps & RefAttributes<HTMLButtonElement>>;
@@ -764,19 +812,54 @@ export declare const ListItem: ForwardRefExoticComponent<ListItemProps & RefAttr
 export declare interface ListItemProps extends Omit<ComponentPropsWithoutRef<'button'>, 'children' | 'disabled' | 'onSelect' | 'value'> {
     item: ListBoxItemData;
     onSelect?: (item: ListBoxItemData) => void;
+    role?: ListItemRole;
     selected?: boolean;
     size?: ListBoxSizes;
 }
 
+export declare type ListItemRole = 'option' | 'menuitem';
+
 export declare const mergeRefs: <T>(...refs: Array<PossibleRef<T>>) => (node: T | null) => (() => void) | undefined;
 
-export declare const MetricCard: FC<IMetricCardProps>;
+export declare function MetricCard({ className, hint, items, label, showDivider, value, ...restProps }: MetricCardProps): JSX.Element;
 
-export declare const MetricValueItem: FC<IMetricValueItem>;
+export declare type MetricCardColorVariant = 'secondary' | 'warning' | 'success' | 'error';
 
-export declare const Modal: FC<ModalProps>;
+export declare interface MetricCardProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    hint?: MetricHint;
+    items?: MetricValueItemData[];
+    label?: LabelProps;
+    showDivider?: boolean;
+    value?: MetricValue;
+}
 
-export declare type ModalIcon = FC<SVGProps<SVGSVGElement>>;
+export declare interface MetricHint {
+    color?: MetricCardColorVariant;
+    text?: ReactNode;
+    trend?: ETrend;
+    trendInverted?: boolean;
+    trendPosition?: TrendPosition;
+}
+
+export declare interface MetricValue {
+    color?: MetricCardColorVariant;
+    supportText?: ReactNode;
+    supportTextSize?: ValueSupportSize;
+    text?: ReactNode;
+    trend?: ETrend;
+    trendInverted?: boolean;
+}
+
+export declare function MetricValueItem({ value, hint }: MetricValueItemData): JSX.Element;
+
+export declare interface MetricValueItemData {
+    hint?: MetricHint;
+    value?: MetricValue;
+}
+
+export declare function Modal({ open, children, title, description, footer, onClose, size, closeLabel, closeOnEscape, closeOnOverlayClick, container, containerId, containerRef, disablePortal, leadingIcon: LeadingIcon, showCloseButton, showOverlay, role, className, ...restProps }: ModalProps): JSX.Element;
+
+export declare type ModalIcon = ComponentType<SVGProps<SVGSVGElement>>;
 
 declare const modalPanelStyles: (props?: ({
     size?: "sm" | "md" | "lg" | null | undefined;
@@ -881,7 +964,7 @@ export declare interface OrgChartRef {
     collapseAll: () => void;
 }
 
-export declare const Popover: FC<PopoverProps>;
+export declare function Popover({ trigger, title, children, open, defaultOpen, onOpenChange, placement, align, variant, closeLabel, closeOnEscape, closeOnOutsideClick, showArrow, showCloseButton, showSlotBorder, className, contentClassName, triggerClassName, ...restProps }: PopoverProps): JSX.Element;
 
 export declare type PopoverAlignments = 'start' | 'center' | 'end';
 
@@ -930,7 +1013,7 @@ declare interface PresenceChildProps {
 
 declare type PrimitiveValue = string | number | boolean | bigint | symbol | null | undefined;
 
-export declare const ProgressBar: FC<ProgressBarProps>;
+export declare function ProgressBar({ appearance, caption, captionClassName, className, fullWidth, indicatorClassName, inverted, label, labelClassName, max, min, role, showDot, showValue, size, trackClassName, value, valueClassName, valueFormatter, variant, 'aria-describedby': ariaDescribedBy, 'aria-label': ariaLabel, 'aria-labelledby': ariaLabelledBy, ...restProps }: ProgressBarProps): JSX.Element;
 
 export declare type ProgressBarAppearances = NonNullable<RemoveNull<VariantProps<typeof progressBarRootStyles>>['appearance']>;
 
@@ -976,14 +1059,15 @@ export declare interface ProgressBarValueFormatterArgs {
 
 export declare type ProgressBarVariants = ButtonVariants;
 
-export declare const Radio: FC<RadioProps>;
+export declare function Radio({ ref, id, label, description, error, size, disabled, required, checked, defaultChecked, className, onChange, 'aria-describedby': ariaDescribedBy, 'aria-invalid': ariaInvalid, ...restProps }: RadioProps): JSX.Element;
 
 declare const radioControlStyles: (props?: ({
     size?: "sm" | "md" | "lg" | null | undefined;
+    hasHelperText?: boolean | null | undefined;
     invalid?: boolean | null | undefined;
 } & ClassProp) | undefined) => string;
 
-export declare const RadioGroup: FC<RadioGroupProps>;
+export declare function RadioGroup({ options, value, defaultValue, onValueChange, name, label, description, error, size, orientation, disabled, required, className, 'aria-describedby': ariaDescribedBy, 'aria-invalid': ariaInvalid, ...restProps }: RadioGroupProps): JSX.Element;
 
 export declare interface RadioGroupOption extends Omit<RadioProps, 'checked' | 'defaultChecked' | 'children' | 'error' | 'name' | 'ref' | 'required' | 'size' | 'type' | 'value'> {
     value: string;
@@ -1016,7 +1100,7 @@ export declare interface RadioProps extends Omit<ComponentPropsWithRef<'input'>,
 
 export declare type RadioSizes = RemoveNull<VariantProps<typeof radioControlStyles>>['size'];
 
-export declare const Rating: FC<RatingProps>;
+export declare function Rating({ ref, className, defaultValue, disabled, getLabelText, max, name, onValueChange, precision, readOnly, size, value, 'aria-label': ariaLabel, ...restProps }: RatingProps): JSX.Element;
 
 export declare type RatingPrecision = 0.5 | 1;
 
@@ -1043,7 +1127,9 @@ export declare type RemoveNull<T> = {
     [K in keyof T]: Exclude<T[K], null>;
 };
 
-export declare const Select: <Option extends SelectOption = SelectOption, IsMulti extends boolean = false>({ ref, id, label, caption, error, errorMsg, hideErrorMsg, hintText, size, variant, fullWidth, containerClassName, labelClassName, inputClassName, disabled, isDisabled, readOnly, readonly, required, isCreatable, createText, placeholder, className, components: customComponents, classNames: customClassNames, styles: customStyles, menuPortalTarget, menuPlacement, menuPosition, isSearchable, isOptionDisabled, getOptionLabel, getOptionValue, formatOptionLabel, formatCreateLabel, menuIsOpen, openMenuOnClick, backspaceRemovesValue, ...restProps }: SelectProps<Option, IsMulti>) => JSX.Element;
+export declare const Select: <Option extends SelectOption = SelectOption, IsMulti extends boolean = false>({ ref, id, label, caption, error, errorMsg, hideErrorMsg, hintText, size, variant, fullWidth, containerClassName, labelClassName, inputClassName, disabled, isDisabled, readOnly, readonly, required, isCreatable, createText, placeholder, className, components: customComponents, classNames: customClassNames, styles: customStyles, menuPortalTarget, menuPlacement, menuPosition, isSearchable, isOptionDisabled, getOptionLabel, getOptionValue, formatOptionLabel, formatCreateLabel, menuIsOpen, openMenuOnClick, backspaceRemovesValue, "aria-describedby": ariaDescribedBy, "aria-invalid": ariaInvalid, ...restProps }: SelectProps<Option, IsMulti>) => JSX.Element;
+
+export declare type SelectAriaInvalid = boolean | 'false' | 'grammar' | 'spelling' | 'true';
 
 export declare interface SelectOption<T = string | number> {
     label: ReactNode;
@@ -1054,6 +1140,8 @@ export declare interface SelectOption<T = string | number> {
 }
 
 export declare interface SelectProps<Option extends SelectOption = SelectOption, IsMulti extends boolean = false> extends Omit<CreatableProps<Option, IsMulti, GroupBase<Option>>, 'size'> {
+    'aria-describedby'?: string;
+    'aria-invalid'?: SelectAriaInvalid;
     caption?: ReactNode;
     containerClassName?: string;
     createText?: string;
@@ -1079,7 +1167,7 @@ export declare type SelectSizes = InputSizes;
 
 export declare type SelectVariants = InputVariants;
 
-export declare const SelectWithApply: <Option extends SelectOption = SelectOption, IsMulti extends boolean = false>({ ref, id, label, caption, error, errorMsg, hideErrorMsg, hintText, size, variant, fullWidth, containerClassName, labelClassName, inputClassName, disabled, isDisabled, readOnly, readonly, required, placeholder, className, classNames: customClassNames, compactDisplay, components: customComponents, isMulti, isOptionDisabled, isSearchable, menuPlacement, menuPortalTarget, menuPosition, onChange, options, styles: customStyles, value, allOptionLabel, applyButtonLabel, ...restProps }: SelectWithApplyProps<Option, IsMulti>) => JSX.Element;
+export declare const SelectWithApply: <Option extends SelectOption = SelectOption, IsMulti extends boolean = false>({ ref, id, label, caption, error, errorMsg, hideErrorMsg, hintText, size, variant, fullWidth, containerClassName, labelClassName, inputClassName, disabled, isDisabled, readOnly, readonly, required, placeholder, className, classNames: customClassNames, compactDisplay, components: customComponents, isMulti, isOptionDisabled, isSearchable, menuPlacement, menuPortalTarget, menuPosition, onChange, options, styles: customStyles, value, allOptionLabel, applyButtonLabel, "aria-describedby": ariaDescribedBy, "aria-invalid": ariaInvalid, ...restProps }: SelectWithApplyProps<Option, IsMulti>) => JSX.Element;
 
 export declare interface SelectWithApplyProps<Option extends SelectOption = SelectOption, IsMulti extends boolean = false> extends SelectProps<Option, IsMulti> {
     allOptionLabel?: string;
@@ -1087,7 +1175,7 @@ export declare interface SelectWithApplyProps<Option extends SelectOption = Sele
     compactDisplay?: boolean;
 }
 
-export declare const Slider: FC<SliderProps>;
+export declare function Slider({ caption, captionClassName, className, defaultValue, disabled, error, formatValue, label, labelClassName, max, min, onValueChange, range, showMaxLabel, showMinLabel, showValueLabel, size, step, thumbClassName, trackClassName, value, valueClassName, 'aria-label': ariaLabel, 'aria-describedby': ariaDescribedBy, 'aria-invalid': ariaInvalid, ...restProps }: SliderProps): JSX.Element;
 
 export declare type SliderLabelSizes = RemoveNull<VariantProps<typeof sliderLabelStyles>>['size'];
 
@@ -1142,7 +1230,7 @@ declare const sliderTrackStyles: (props?: ({
 
 export declare type SliderValue = number | [number, number];
 
-export declare const Tab: FC<InternalTabProps>;
+export declare function Tab({ children, className, closeLabel, disabled, endAdornment, index, onClose, panelId, selected, startAdornment, statusDot, ...restProps }: InternalTabProps): JSX.Element;
 
 export declare type TabKeyboardEvent = KeyboardEvent_2<HTMLDivElement>;
 
@@ -1212,7 +1300,7 @@ export declare const TableRow: ForwardRefExoticComponent<Omit< DetailedHTMLProps
 
 export declare interface TableSectionProps {
     children: ReactNode;
-    className?: string;
+    className?: string | undefined;
 }
 
 export declare type TableSizes = InputSizes;
@@ -1222,7 +1310,7 @@ declare const tabListStyles: (props?: ({
     variant?: "underline" | "pill" | null | undefined;
 } & ClassProp) | undefined) => string;
 
-export declare const TabPanel: FC<TabPanelProps>;
+export declare function TabPanel({ children, className, ...restProps }: TabPanelProps): JSX.Element;
 
 export declare type TabPanelOrientation = RemoveNull<VariantProps<typeof tabPanelStyles>>['orientation'];
 
@@ -1252,7 +1340,7 @@ declare const tabRootStyles: (props?: ({
     disabled?: boolean | null | undefined;
 } & ClassProp) | undefined) => string;
 
-export declare const Tabs: FC<TabsProps>;
+export declare function Tabs({ children, className, defaultValue, disabled, id, onValueChange, orientation, size, value, variant, ...restProps }: TabsProps): JSX.Element;
 
 export declare interface TabsContextValue {
     baseId: string;
@@ -1264,7 +1352,7 @@ export declare interface TabsContextValue {
     variant: NonNullable<TabsProps['variant']>;
 }
 
-export declare const TabsList: FC<TabsListProps>;
+export declare function TabsList({ children, className, ...restProps }: TabsListProps): JSX.Element;
 
 export declare interface TabsListContextValue extends TabsContextValue {
     registerTab: (index: number, node: HTMLDivElement | null) => void;
@@ -1304,7 +1392,7 @@ export declare type TabsSizes = RemoveNull<VariantProps<typeof tabRootStyles>>['
 
 export declare type TabsVariant = RemoveNull<VariantProps<typeof tabRootStyles>>['variant'];
 
-export declare const TextArea: FC<TextAreaProps>;
+export declare function TextArea({ ref, id, label, caption, error, size, variant, fullWidth, containerClassName, labelClassName, textAreaClassName, className, disabled, required, value, defaultValue, maxLength, onChange, rows, 'aria-describedby': ariaDescribedBy, 'aria-invalid': ariaInvalid, ...restProps }: TextAreaProps): JSX.Element;
 
 export declare interface TextAreaProps extends Omit<ComponentPropsWithRef<'textarea'>, 'children' | 'size'> {
     caption?: ReactNode;
@@ -1322,30 +1410,31 @@ export declare type TextAreaSizes = ButtonSizes;
 
 export declare type TextAreaVariants = ButtonVariants;
 
-export declare type TMetricCardColorVariant = 'secondary' | 'warning' | 'success' | 'error';
+export declare type TMetricCardColorVariant = MetricCardColorVariant;
 
-export declare const Toaster: FC<ToasterProps>;
+export declare function Toaster({ className, position, toastOptions, ...restProps }: ToasterProps): JSX.Element;
 
 export declare interface ToastProps extends AlertProps {
+    dismissable?: boolean;
     duration?: number;
     position?: ToasterProps['position'];
-    dismissable?: boolean;
 }
 
-export declare const Tooltip: ForwardRefExoticComponent<Omit<TooltipProps, "ref"> & RefAttributes<TooltipRefProps>>;
+export declare const Tooltip: ForwardRefExoticComponent<TooltipProps & RefAttributes<TooltipRefProps>>;
 
 export declare interface TooltipProps extends Omit<ITooltip, 'variant'> {
     variant?: 'primary' | 'secondary';
-    ref?: Ref<TooltipRefProps>;
 }
 
+export { TooltipRefProps }
+
 export declare const TREND_INDICATOR_COLORS: {
     positive: string;
     negative: string;
     neutral: string;
 };
 
-export declare const TrendIndicator: FC<TrendIndicatorProps>;
+export declare function TrendIndicator({ className, colorizeValueText, inverted, label, size, strokeWidth, value, variant, ...restProps }: TrendIndicatorProps): JSX.Element;
 
 export declare const trendIndicatorColors: {
     positive: string;
@@ -1353,10 +1442,9 @@ export declare const trendIndicatorColors: {
     neutral: string;
 };
 
-export declare interface TrendIndicatorProps {
-    className?: HTMLProps<HTMLElement>['className'];
+export declare interface TrendIndicatorProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children'> {
     colorizeValueText?: boolean;
-    inverted?: boolean | undefined;
+    inverted?: boolean;
     label?: ReactNode;
     size?: TrendIndicatorSize;
     strokeWidth?: TrendIndicatorStrokeWidth;
@@ -1368,9 +1456,11 @@ export declare type TrendIndicatorSize = 'sm' | 'md' | 'lg';
 
 export declare type TrendIndicatorStrokeWidth = 'thin' | 'thick' | 'thicker';
 
-export declare type TTrendPosition = 'left' | 'right';
+declare type TrendPosition = 'left' | 'right';
 
-export declare type TValueSupportSize = 'sm' | 'lg';
+export declare type TTrendPosition = TrendPosition;
+
+export declare type TValueSupportSize = ValueSupportSize;
 
 export declare const useTheme: () => {
     theme: EThemeOptions;
@@ -1378,7 +1468,7 @@ export declare const useTheme: () => {
     setTheme: (theme: EThemeOptions) => void;
 };
 
-export declare const useToast: () => {
+export declare function useToast(): {
     toast: (props: ToastProps) => string | number;
     default: (props: Omit<ToastProps, "variant">) => string | number;
     primary: (props: Omit<ToastProps, "variant">) => string | number;
@@ -1392,4 +1482,6 @@ export declare const useToast: () => {
 
 export declare const useToggle: () => readonly [boolean, () => void];
 
+declare type ValueSupportSize = 'sm' | 'lg';
+
 export { }