@tanishraj/ui-kit 2.4.1 → 2.5.3

package/dist/index.d.ts

@@ -1,23 +1,41 @@
-import { AnchorHTMLAttributes } from 'react';
+import { ActionMeta } from 'react-select';
+import { AsyncCreatableProps } from 'react-select/async-creatable';
+import { AsyncProps } from 'react-select/async';
 import { ClassProp } from 'class-variance-authority/types';
 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';
 import { FieldsetHTMLAttributes } from 'react';
 import { ForwardRefExoticComponent } from 'react';
+import { GroupBase } from 'react-select';
 import { HTMLAttributes } 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';
 import { ReactElement } from 'react';
 import { ReactNode } from 'react';
 import { Ref } from 'react';
 import { RefAttributes } from 'react';
 import { RefObject } from 'react';
-import { RemoveNull as RemoveNull_2 } from '../../../utils';
+import { SelectInstance } from 'react-select';
 import { SVGProps } from 'react';
 import { ToasterProps } from 'sonner';
+import { TooltipRefProps } from 'react-tooltip';
 import { VariantProps } from 'class-variance-authority';
 
 export declare const Accordion: FC<AccordionProps>;
@@ -29,7 +47,7 @@ export declare interface AccordionItem {
     disabled?: boolean;
 }
 
-export declare interface AccordionProps extends ComponentPropsWithRef<'div'>, RemoveNull_2<VariantProps<typeof accordionRootStyles>> {
+export declare interface AccordionProps extends ComponentPropsWithRef<'div'>, RemoveNull<VariantProps<typeof accordionRootStyles>> {
     items: AccordionItem[];
     type?: AccordionType;
     value?: string | string[];
@@ -42,24 +60,27 @@ declare const accordionRootStyles: (props?: ({
     size?: "sm" | "md" | "lg" | null | undefined;
 } & ClassProp) | undefined) => string;
 
-export declare type AccordionSizes = RemoveNull_2<VariantProps<typeof accordionRootStyles>>['size'];
+export declare type AccordionSizes = RemoveNull<VariantProps<typeof accordionRootStyles>>['size'];
 
 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_2<VariantProps<typeof alertWrapperStyles>>['appearance'];
+export declare type AlertAppearances = RemoveNull<VariantProps<typeof alertWrapperStyles>>['appearance'];
 
-export declare interface AlertProps extends RemoveNull_2<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_2<VariantProps<typeof alertWrapperStyles>>['size'];
+export declare type AlertSizes = RemoveNull<VariantProps<typeof alertWrapperStyles>>['size'];
 
-export declare type AlertVariants = RemoveNull_2<VariantProps<typeof alertWrapperStyles>>['variant'];
+export declare type AlertVariants = RemoveNull<VariantProps<typeof alertWrapperStyles>>['variant'];
 
 declare const alertWrapperStyles: (props?: ({
     appearance?: "filled" | "outline" | "dashed" | null | undefined;
@@ -68,16 +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 Avatar: FC<AvatarProps>;
+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 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;
@@ -87,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;
@@ -101,18 +130,18 @@ export declare interface AvatarGroupProps extends Omit<HTMLAttributes<HTMLDivEle
     stroke?: boolean;
 }
 
-export declare type AvatarGroupShapes = RemoveNull_2<VariantProps<typeof avatarContainerStyles>>['shape'];
+export declare type AvatarGroupShapes = RemoveNull<VariantProps<typeof avatarContainerStyles>>['shape'];
 
-export declare type AvatarGroupSizes = RemoveNull_2<VariantProps<typeof avatarContainerStyles>>['size'];
+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;
@@ -125,11 +154,11 @@ export declare interface AvatarProps extends HTMLAttributes<HTMLSpanElement>, Om
     stroke?: boolean;
 }
 
-export declare type AvatarShapes = RemoveNull_2<VariantProps<typeof avatarContainerStyles>>['shape'];
+export declare type AvatarShapes = RemoveNull<VariantProps<typeof avatarContainerStyles>>['shape'];
 
-export declare type AvatarSizes = RemoveNull_2<VariantProps<typeof avatarContainerStyles>>['size'];
+export declare type AvatarSizes = RemoveNull<VariantProps<typeof avatarContainerStyles>>['size'];
 
-export declare type AvatarStatus = RemoveNull_2<VariantProps<typeof avatarStatusStyles>['status']>;
+export declare type AvatarStatus = RemoveNull<VariantProps<typeof avatarStatusStyles>['status']>;
 
 export declare type AvatarStatusPosition = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
 
@@ -140,44 +169,58 @@ declare const avatarStatusStyles: (props?: ({
     size?: "sm" | "md" | "lg" | "xs" | null | undefined;
 } & ClassProp) | undefined) => string;
 
-export declare type AvatarVariants = RemoveNull_2<VariantProps<typeof avatarContainerStyles>>['variant'];
+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_2<VariantProps<typeof badgeVariants>>['appearance'];
+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_2<VariantProps<typeof badgeVariants>>['shape'];
+export declare type BadgeShapes = RemoveNull<VariantProps<typeof badgeVariants>>['shape'];
 
-export declare type BadgeSizes = RemoveNull_2<VariantProps<typeof badgeVariants>>['size'];
+export declare type BadgeSizes = RemoveNull<VariantProps<typeof badgeVariants>>['size'];
 
-export declare type BadgeVariants = RemoveNull_2<VariantProps<typeof badgeVariants>>['variant'];
+export declare type BadgeVariants = RemoveNull<VariantProps<typeof badgeVariants>>['variant'];
 
 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_2<VariantProps<typeof breadcrumbStyles>>['appearance'];
+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;
@@ -189,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_2<VariantProps<typeof buttonStyles>>['appearance'];
+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;
@@ -202,25 +245,26 @@ 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_2<VariantProps<typeof buttonStyles>>['shape'];
+export declare type ButtonShapes = RemoveNull<VariantProps<typeof buttonStyles>>['shape'];
 
-export declare type ButtonSizes = RemoveNull_2<VariantProps<typeof buttonStyles>>['size'];
+export declare type ButtonSizes = RemoveNull<VariantProps<typeof buttonStyles>>['size'];
 
 declare const buttonStyles: (props?: ({
     size?: "sm" | "md" | "lg" | null | undefined;
@@ -230,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_2<VariantProps<typeof buttonStyles>>['variant'];
+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;
 }
 
@@ -280,15 +334,21 @@ export declare interface CheckboxProps extends Omit<ComponentPropsWithRef<'input
     indeterminate?: boolean;
 }
 
-export declare type CheckboxShapes = RemoveNull_2<VariantProps<typeof checkboxControlStyles>>['shape'];
+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 type CheckboxSizes = RemoveNull_2<VariantProps<typeof checkboxControlStyles>>['size'];
+export declare interface CheckboxSelectProps<Option extends SelectOption = SelectOption, IsMulti extends boolean = false> extends SelectProps<Option, IsMulti> {
+    compactDisplay?: boolean;
+}
 
-export declare const Chip: FC<ChipProps>;
+export declare type CheckboxShapes = RemoveNull<VariantProps<typeof checkboxControlStyles>>['shape'];
 
-export declare type ChipIcon = FC<SVGProps<SVGSVGElement>>;
+export declare type CheckboxSizes = RemoveNull<VariantProps<typeof checkboxControlStyles>>['size'];
 
-export declare interface ChipProps extends Omit<ComponentPropsWithoutRef<'span'>, 'children'>, RemoveNull_2<Omit<VariantProps<typeof chipStyles>, 'disabled' | 'hasLeadingVisual' | 'removable'>> {
+export declare function Chip({ children, icon: Icon, variant, appearance, size, shape, inverted, disabled, onClose, closeLabel, className, ...restProps }: ChipProps): JSX.Element;
+
+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;
     icon?: ChipIcon;
     disabled?: boolean;
@@ -296,9 +356,9 @@ export declare interface ChipProps extends Omit<ComponentPropsWithoutRef<'span'>
     closeLabel?: string;
 }
 
-export declare type ChipShapes = RemoveNull_2<VariantProps<typeof chipStyles>>['shape'];
+export declare type ChipShapes = RemoveNull<VariantProps<typeof chipStyles>>['shape'];
 
-export declare type ChipSizes = RemoveNull_2<VariantProps<typeof chipStyles>>['size'];
+export declare type ChipSizes = RemoveNull<VariantProps<typeof chipStyles>>['size'];
 
 declare const chipStyles: (props?: ({
     variant?: "default" | "primary" | "info" | "success" | "warning" | "danger" | null | undefined;
@@ -311,15 +371,99 @@ declare const chipStyles: (props?: ({
     inverted?: boolean | null | undefined;
 } & ClassProp) | undefined) => string;
 
-export declare type ChipVariants = RemoveNull_2<VariantProps<typeof chipStyles>>['variant'];
+export declare type ChipVariants = RemoveNull<VariantProps<typeof chipStyles>>['variant'];
 
 export declare const cn: (...inputs: ClassValue[]) => string;
 
-export declare const Divider: FC<DividerProps>;
+export declare const CompactList: <T extends ItemType>({ badgeProps, displayKey, includeAll, items, lineClampSize, maxVisible, popoverClassName, renderItem, }: CompactListProps<T>) => JSX.Element | null;
+
+export declare interface CompactListProps<T extends ItemType> {
+    badgeProps?: Omit<BadgeProps, 'children'>;
+    displayKey?: T extends ObjectItem ? keyof T : never;
+    includeAll?: boolean;
+    items: T[];
+    lineClampSize?: number;
+    maxVisible?: number;
+    popoverClassName?: string;
+    renderItem?: (item: T, index: number) => ReactNode;
+}
+
+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 = ComponentType<SVGProps<SVGSVGElement>>;
 
-export declare type DividerOrientations = RemoveNull_2<VariantProps<typeof dividerRootStyles>>['orientation'];
+declare const confirmationPopupIconStyles: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+    variant?: "default" | "primary" | "info" | "success" | "warning" | "danger" | null | undefined;
+} & ClassProp) | undefined) => string;
+
+declare const confirmationPopupPanelStyles: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & ClassProp) | undefined) => string;
+
+export declare type ConfirmationPopupPlacements = 'top' | 'right' | 'bottom' | 'left';
 
-export declare interface DividerProps extends HTMLAttributes<HTMLDivElement> {
+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;
+    children?: ReactNode;
+    placement?: ConfirmationPopupPlacements;
+    align?: ConfirmationPopupAlignments;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    onClose?: () => void;
+    onCancel?: (event: MouseEvent_2<HTMLButtonElement>) => void;
+    onAction?: (event: MouseEvent_2<HTMLButtonElement>) => void;
+    closeLabel?: string;
+    cancelLabel?: ReactNode;
+    actionLabel?: ReactNode;
+    closeOnEscape?: boolean;
+    closeOnOutsideClick?: boolean;
+    closeOnCancel?: boolean;
+    closeOnAction?: boolean;
+    portalled?: boolean;
+    showArrow?: boolean;
+    showCloseButton?: boolean;
+    showCancelButton?: boolean;
+    showActionButton?: boolean;
+    leadingIcon?: ConfirmationPopupIcon;
+    contentClassName?: string;
+    triggerClassName?: string;
+    actionButtonProps?: Partial<ButtonProps>;
+    cancelButtonProps?: Partial<ButtonProps>;
+}
+
+export declare type ConfirmationPopupSizes = RemoveNull<VariantProps<typeof confirmationPopupPanelStyles>>['size'];
+
+export declare type ConfirmationPopupVariants = RemoveNull<VariantProps<typeof confirmationPopupIconStyles>>['variant'];
+
+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;
+    name?: string;
+    size?: CountryFlagSize;
+}
+
+export declare type CountryFlagSize = 'xs' | 'sm' | 'md' | 'lg';
+
+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 ComponentPropsWithoutRef<'div'> {
     children?: ReactNode;
     orientation?: DividerOrientations;
 }
@@ -329,16 +473,16 @@ 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;
     size?: "sm" | "md" | "lg" | "full" | null | undefined;
 } & ClassProp) | undefined) => string;
 
-export declare type DrawerPlacements = RemoveNull_2<VariantProps<typeof drawerPanelStyles>>['placement'];
+export declare type DrawerPlacements = RemoveNull<VariantProps<typeof drawerPanelStyles>>['placement'];
 
-export declare interface DrawerProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'>, RemoveNull_2<VariantProps<typeof drawerPanelStyles>> {
+export declare interface DrawerProps extends Omit<ComponentPropsWithoutRef<'div'>, 'title'>, RemoveNull<VariantProps<typeof drawerPanelStyles>> {
     open: boolean;
     children?: ReactNode;
     title?: ReactNode;
@@ -356,9 +500,9 @@ export declare interface DrawerProps extends Omit<HTMLAttributes<HTMLDivElement>
     showOverlay?: boolean;
 }
 
-export declare type DrawerSizes = RemoveNull_2<VariantProps<typeof drawerPanelStyles>>['size'];
+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';
 
@@ -409,12 +553,44 @@ 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"
 }
 
-export declare const Feedback: FC<FeedbackProps>;
+export declare enum ETrend {
+    positive = "positive",
+    negative = "negative",
+    neutral = "neutral"
+}
+
+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;
 
@@ -442,13 +618,78 @@ export declare interface FeedbackProps extends Omit<ComponentPropsWithRef<'div'>
     variant?: FeedbackVariant;
 }
 
-export declare type FeedbackSizes = RemoveNull_2<VariantProps<typeof feedbackOptionStyles>>['size'];
+export declare type FeedbackSizes = RemoveNull<VariantProps<typeof feedbackOptionStyles>>['size'];
 
 export declare type FeedbackVariant = 'face' | 'emoji';
 
-export declare const Input: FC<InputProps>;
+export declare const getGrowthTrend: ({ currentValue, pastValue, isPercentage, hasFractionDigits, isPointValue, }: {
+    currentValue: number;
+    pastValue: number;
+    isPercentage?: boolean;
+    hasFractionDigits?: boolean;
+    isPointValue?: boolean;
+}) => {
+    growth: number;
+    trend: ETrend;
+};
+
+export declare const getTrendVariant: (value: number | null | undefined, customThreshold?: number) => ETrend;
 
-export declare type InputIcon = FC<SVGProps<SVGSVGElement>>;
+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;
+}
+
+export declare interface GroupedSelectProps<Option extends GroupedSelectOption = GroupedSelectOption> {
+    caption?: ReactNode;
+    className?: string;
+    compactDisplay?: boolean;
+    containerClassName?: string;
+    disabled?: boolean;
+    error?: ReactNode;
+    errorMsg?: ReactNode;
+    fullWidth?: boolean;
+    hideErrorMsg?: boolean;
+    hideSelectedOptions?: boolean;
+    hintText?: ReactNode;
+    inputClassName?: string;
+    isClearable?: boolean;
+    isSearchable?: boolean;
+    label?: ReactNode;
+    labelClassName?: string;
+    menuIsOpen?: boolean;
+    menuPlacement?: 'auto' | 'top' | 'bottom';
+    menuPortalTarget?: HTMLElement | null;
+    menuPosition?: 'absolute' | 'fixed';
+    onChange?: (newValue: MultiValue<Option>, actionMeta: ActionMeta<Option>) => void;
+    options: readonly GroupBase<Option>[];
+    placeholder?: ReactNode;
+    readOnly?: boolean;
+    readonly?: boolean;
+    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 type IMetricCardProps = MetricCardProps;
+
+export declare type IMetricHint = MetricHint;
+
+export declare type IMetricValue = MetricValue;
+
+export declare type IMetricValueItem = MetricValueItemData;
+
+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 = ComponentType<SVGProps<SVGSVGElement>>;
 
 export declare interface InputProps extends Omit<ComponentPropsWithRef<'input'>, 'children' | 'prefix' | 'size'> {
     caption?: ReactNode;
@@ -456,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;
 }
 
@@ -485,11 +729,34 @@ export declare interface InternalTabProps extends TabProps {
     selected?: boolean;
 }
 
-export declare const Link: FC<LinkProps>;
+declare type ItemType = PrimitiveValue | ObjectItem;
+
+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';
+
+export declare interface LabelProps extends LabelHTMLAttributes<HTMLLabelElement> {
+    disabled?: boolean;
+    endAdornment?: ReactNode;
+    labelWeight?: LabelWeight;
+    position?: LabelPosition;
+    required?: boolean;
+    size?: LabelSize;
+    text?: ReactNode;
+    variant?: LabelVariant;
+}
+
+export declare type LabelSize = 'lg' | 'md' | 'sm';
+
+export declare type LabelVariant = 'primary' | 'secondary' | 'tertiary';
+
+export declare type LabelWeight = 'semibold' | 'medium' | 'normal';
 
-export declare type LinkIcon = FC<SVGProps<SVGSVGElement>>;
+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 interface LinkProps extends Omit<ComponentPropsWithRef<'a'>, 'children'>, RemoveNull_2<Omit<VariantProps<typeof linkStyles>, 'disabled' | 'truncate'>> {
+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;
     leadingIcon?: LinkIcon;
     trailingIcon?: LinkIcon;
@@ -498,7 +765,7 @@ export declare interface LinkProps extends Omit<ComponentPropsWithRef<'a'>, 'chi
     truncate?: boolean;
 }
 
-export declare type LinkSizes = RemoveNull_2<VariantProps<typeof linkStyles>>['size'];
+export declare type LinkSizes = RemoveNull<VariantProps<typeof linkStyles>>['size'];
 
 declare const linkStyles: (props?: ({
     variant?: "default" | "primary" | "info" | "success" | "warning" | "danger" | null | undefined;
@@ -509,13 +776,13 @@ declare const linkStyles: (props?: ({
     truncate?: boolean | null | undefined;
 } & ClassProp) | undefined) => string;
 
-export declare type LinkUnderline = RemoveNull_2<VariantProps<typeof linkStyles>>['underline'];
+export declare type LinkUnderline = RemoveNull<VariantProps<typeof linkStyles>>['underline'];
 
-export declare type LinkVariants = RemoveNull_2<VariantProps<typeof linkStyles>>['variant'];
+export declare type LinkVariants = RemoveNull<VariantProps<typeof linkStyles>>['variant'];
 
 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;
@@ -525,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>>;
@@ -542,21 +812,60 @@ 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 Modal: FC<ModalProps>;
+export declare function MetricCard({ className, hint, items, label, showDivider, value, ...restProps }: MetricCardProps): JSX.Element;
+
+export declare type MetricCardColorVariant = 'secondary' | 'warning' | 'success' | 'error';
+
+export declare interface MetricCardProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    hint?: MetricHint;
+    items?: MetricValueItemData[];
+    label?: LabelProps;
+    showDivider?: boolean;
+    value?: MetricValue;
+}
+
+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 type ModalIcon = FC<SVGProps<SVGSVGElement>>;
+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;
 } & ClassProp) | undefined) => string;
 
-export declare interface ModalProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'>, RemoveNull_2<VariantProps<typeof modalPanelStyles>> {
+export declare interface ModalProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'>, RemoveNull<VariantProps<typeof modalPanelStyles>> {
     open: boolean;
     children?: ReactNode;
     title?: ReactNode;
@@ -575,7 +884,13 @@ export declare interface ModalProps extends Omit<HTMLAttributes<HTMLDivElement>,
     showOverlay?: boolean;
 }
 
-export declare type ModalSizes = RemoveNull_2<VariantProps<typeof modalPanelStyles>>['size'];
+export declare type ModalSizes = RemoveNull<VariantProps<typeof modalPanelStyles>>['size'];
+
+export declare const MultiSelectCompact: <Option extends SelectOption = SelectOption>(props: MultiSelectCompactProps<Option>) => JSX.Element;
+
+export declare type MultiSelectCompactProps<Option extends SelectOption = SelectOption> = Omit<CheckboxSelectProps<Option, true>, 'compactDisplay' | 'isMulti'>;
+
+declare type ObjectItem = Record<string, unknown>;
 
 export declare const OrganizationChart: ForwardRefExoticComponent<OrgChartComponentProps & RefAttributes<OrgChartRef>>;
 
@@ -649,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';
 
@@ -659,7 +974,7 @@ declare const popoverIconStyles: (props?: ({
 
 export declare type PopoverPlacements = 'top' | 'right' | 'bottom' | 'left';
 
-export declare interface PopoverProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'>, RemoveNull_2<VariantProps<typeof popoverIconStyles>> {
+export declare interface PopoverProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'>, RemoveNull<VariantProps<typeof popoverIconStyles>> {
     trigger?: ReactNode;
     title?: ReactNode;
     children?: ReactNode;
@@ -678,7 +993,7 @@ export declare interface PopoverProps extends Omit<HTMLAttributes<HTMLDivElement
     triggerClassName?: string;
 }
 
-export declare type PopoverVariants = RemoveNull_2<VariantProps<typeof popoverIconStyles>>['variant'];
+export declare type PopoverVariants = RemoveNull<VariantProps<typeof popoverIconStyles>>['variant'];
 
 export declare const Portal: FC<PortalProps>;
 
@@ -696,9 +1011,11 @@ declare interface PresenceChildProps {
     children: ReactElement;
 }
 
-export declare const ProgressBar: FC<ProgressBarProps>;
+declare type PrimitiveValue = string | number | boolean | bigint | symbol | null | undefined;
 
-export declare type ProgressBarAppearances = NonNullable<RemoveNull_2<VariantProps<typeof progressBarRootStyles>>['appearance']>;
+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']>;
 
 export declare interface ProgressBarProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
     appearance?: ProgressBarAppearances;
@@ -726,7 +1043,7 @@ declare const progressBarRootStyles: (props?: ({
     fullWidth?: boolean | null | undefined;
 } & ClassProp) | undefined) => string;
 
-export declare type ProgressBarSizes = NonNullable<RemoveNull_2<VariantProps<typeof progressBarTrackStyles>>['size']>;
+export declare type ProgressBarSizes = NonNullable<RemoveNull<VariantProps<typeof progressBarTrackStyles>>['size']>;
 
 declare const progressBarTrackStyles: (props?: ({
     size?: "sm" | "md" | "lg" | null | undefined;
@@ -742,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;
@@ -780,9 +1098,9 @@ export declare interface RadioProps extends Omit<ComponentPropsWithRef<'input'>,
     size?: RadioSizes;
 }
 
-export declare type RadioSizes = RemoveNull_2<VariantProps<typeof radioControlStyles>>['size'];
+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;
 
@@ -799,7 +1117,7 @@ export declare interface RatingProps extends Omit<ComponentPropsWithRef<'div'>,
     value?: number;
 }
 
-export declare type RatingSizes = RemoveNull_2<VariantProps<typeof ratingStarStyles>>['size'];
+export declare type RatingSizes = RemoveNull<VariantProps<typeof ratingStarStyles>>['size'];
 
 declare const ratingStarStyles: (props?: ({
     size?: "sm" | "md" | "lg" | "xs" | null | undefined;
@@ -809,9 +1127,57 @@ export declare type RemoveNull<T> = {
     [K in keyof T]: Exclude<T[K], null>;
 };
 
-export declare const Slider: FC<SliderProps>;
+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;
+    value?: T;
+    __isNew__?: boolean;
+    disabled?: boolean;
+    options?: SelectOption<T>[];
+}
+
+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;
+    disabled?: boolean;
+    error?: ReactNode;
+    errorMsg?: ReactNode;
+    fullWidth?: boolean;
+    hideErrorMsg?: boolean;
+    hintText?: ReactNode;
+    inputClassName?: string;
+    isCreatable?: boolean;
+    label?: ReactNode;
+    labelClassName?: string;
+    readOnly?: boolean;
+    readonly?: boolean;
+    ref?: Ref<SelectInstance<Option, IsMulti, GroupBase<Option>>>;
+    required?: boolean;
+    size?: SelectSizes;
+    variant?: SelectVariants;
+}
+
+export declare type SelectSizes = InputSizes;
+
+export declare type SelectVariants = InputVariants;
 
-export declare type SliderLabelSizes = RemoveNull_2<VariantProps<typeof sliderLabelStyles>>['size'];
+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;
+    applyButtonLabel?: string;
+    compactDisplay?: boolean;
+}
+
+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'];
 
 declare const sliderLabelStyles: (props?: ({
     size?: "sm" | "md" | "lg" | null | undefined;
@@ -842,7 +1208,7 @@ export declare interface SliderProps extends Omit<ComponentPropsWithRef<'div'>,
     valueClassName?: string;
 }
 
-export declare type SliderSizes = RemoveNull_2<VariantProps<typeof sliderTrackStyles>>['size'];
+export declare type SliderSizes = RemoveNull<VariantProps<typeof sliderTrackStyles>>['size'];
 
 export declare interface SliderState {
     max: number;
@@ -850,7 +1216,7 @@ export declare interface SliderState {
     values: [number, number?];
 }
 
-export declare type SliderThumbSizes = RemoveNull_2<VariantProps<typeof sliderThumbStyles>>['size'];
+export declare type SliderThumbSizes = RemoveNull<VariantProps<typeof sliderThumbStyles>>['size'];
 
 declare const sliderThumbStyles: (props?: ({
     size?: "sm" | "md" | "lg" | null | undefined;
@@ -864,18 +1230,89 @@ 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>;
 
+export declare const Table: <RowData extends object = Record<string, unknown>>(props: TableProps<RowData>) => React.JSX.Element;
+
+export declare type TableAlign = 'left' | 'center' | 'right';
+
+export declare const TableBody: ForwardRefExoticComponent<TableSectionProps & RefAttributes<HTMLTableSectionElement>>;
+
+export declare const TableCaption: ForwardRefExoticComponent<TableCaptionProps & RefAttributes<HTMLTableCaptionElement>>;
+
+export declare interface TableCaptionProps extends ComponentPropsWithoutRef<'caption'> {
+    side?: 'top' | 'bottom';
+}
+
+export declare const TableCell: ForwardRefExoticComponent<TableCellProps & RefAttributes<HTMLTableCellElement>>;
+
+export declare interface TableCellProps extends ComponentPropsWithoutRef<'td'> {
+    align?: TableAlign | undefined;
+}
+
+export declare interface TableColumn<RowData> {
+    accessorKey?: keyof RowData;
+    align?: TableAlign;
+    cell?: (row: RowData, rowIndex: number) => ReactNode;
+    className?: string;
+    header: ReactNode;
+    headerClassName?: string;
+    id?: string;
+}
+
+export declare interface TableContextValue {
+    interactive: boolean;
+    showColumnBorder: boolean;
+    size: TableSizes;
+    stickyHeader: boolean;
+    striped: boolean;
+}
+
+export declare const TableFooter: ForwardRefExoticComponent<TableSectionProps & RefAttributes<HTMLTableSectionElement>>;
+
+export declare const TableHead: ForwardRefExoticComponent<TableHeadProps & RefAttributes<HTMLTableCellElement>>;
+
+export declare const TableHeader: ForwardRefExoticComponent<TableSectionProps & RefAttributes<HTMLTableSectionElement>>;
+
+export declare interface TableHeadProps extends ComponentPropsWithoutRef<'th'> {
+    align?: TableAlign | undefined;
+}
+
+export declare interface TableProps<RowData extends object = Record<string, unknown>> extends Omit<ComponentPropsWithoutRef<'table'>, 'children' | 'size'> {
+    caption?: ReactNode;
+    captionSide?: 'top' | 'bottom';
+    columns: TableColumn<RowData>[];
+    containerClassName?: string;
+    data: RowData[];
+    emptyMessage?: ReactNode;
+    footer?: ReactNode;
+    interactive?: boolean;
+    rowKey?: keyof RowData | ((row: RowData, index: number) => Key);
+    showColumnBorder?: boolean;
+    size?: TableSizes;
+    stickyHeader?: boolean;
+    striped?: boolean;
+}
+
+export declare const TableRow: ForwardRefExoticComponent<Omit< DetailedHTMLProps<HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>, "ref"> & RefAttributes<HTMLTableRowElement>>;
+
+export declare interface TableSectionProps {
+    children: ReactNode;
+    className?: string | undefined;
+}
+
+export declare type TableSizes = InputSizes;
+
 declare const tabListStyles: (props?: ({
     orientation?: "horizontal" | "vertical" | null | undefined;
     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_2<VariantProps<typeof tabPanelStyles>>['orientation'];
+export declare type TabPanelOrientation = RemoveNull<VariantProps<typeof tabPanelStyles>>['orientation'];
 
 export declare interface TabPanelProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children'> {
     children: ReactNode;
@@ -903,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;
@@ -915,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;
@@ -931,7 +1368,7 @@ export declare interface TabsListProps extends Omit<ComponentPropsWithoutRef<'di
     children: ReactNode;
 }
 
-export declare type TabsOrientation = RemoveNull_2<VariantProps<typeof tabsRootStyles>>['orientation'];
+export declare type TabsOrientation = RemoveNull<VariantProps<typeof tabsRootStyles>>['orientation'];
 
 export declare interface TabsProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children' | 'defaultValue' | 'onChange'> {
     children: ReactNode;
@@ -945,31 +1382,93 @@ export declare interface TabsProps extends Omit<ComponentPropsWithoutRef<'div'>,
     variant?: TabsVariant;
 }
 
-export declare type TabsRootOrientation = RemoveNull_2<VariantProps<typeof tabListStyles>>['orientation'];
+export declare type TabsRootOrientation = RemoveNull<VariantProps<typeof tabListStyles>>['orientation'];
 
 declare const tabsRootStyles: (props?: ({
     orientation?: "horizontal" | "vertical" | null | undefined;
 } & ClassProp) | undefined) => string;
 
-export declare type TabsSizes = RemoveNull_2<VariantProps<typeof tabRootStyles>>['size'];
+export declare type TabsSizes = RemoveNull<VariantProps<typeof tabRootStyles>>['size'];
 
-export declare type TabsVariant = RemoveNull_2<VariantProps<typeof tabRootStyles>>['variant'];
+export declare type TabsVariant = RemoveNull<VariantProps<typeof tabRootStyles>>['variant'];
 
-export declare const Toaster: FC<ToasterProps>;
+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;
+    containerClassName?: string;
+    error?: ReactNode;
+    fullWidth?: boolean;
+    label?: ReactNode;
+    labelClassName?: string;
+    size?: TextAreaSizes;
+    textAreaClassName?: string;
+    variant?: TextAreaVariants;
+}
+
+export declare type TextAreaSizes = ButtonSizes;
+
+export declare type TextAreaVariants = ButtonVariants;
+
+export declare type TMetricCardColorVariant = MetricCardColorVariant;
+
+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<TooltipProps & RefAttributes<TooltipRefProps>>;
+
+export declare interface TooltipProps extends Omit<ITooltip, 'variant'> {
+    variant?: 'primary' | 'secondary';
+}
+
+export { TooltipRefProps }
+
+export declare const TREND_INDICATOR_COLORS: {
+    positive: string;
+    negative: string;
+    neutral: string;
+};
+
+export declare function TrendIndicator({ className, colorizeValueText, inverted, label, size, strokeWidth, value, variant, ...restProps }: TrendIndicatorProps): JSX.Element;
+
+export declare const trendIndicatorColors: {
+    positive: string;
+    negative: string;
+    neutral: string;
+};
+
+export declare interface TrendIndicatorProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children'> {
+    colorizeValueText?: boolean;
+    inverted?: boolean;
+    label?: ReactNode;
+    size?: TrendIndicatorSize;
+    strokeWidth?: TrendIndicatorStrokeWidth;
+    value?: ReactNode;
+    variant?: ETrend;
+}
+
+export declare type TrendIndicatorSize = 'sm' | 'md' | 'lg';
+
+export declare type TrendIndicatorStrokeWidth = 'thin' | 'thick' | 'thicker';
+
+declare type TrendPosition = 'left' | 'right';
+
+export declare type TTrendPosition = TrendPosition;
+
+export declare type TValueSupportSize = ValueSupportSize;
+
 export declare const useTheme: () => {
     theme: EThemeOptions;
     isDark: boolean;
     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;
@@ -983,4 +1482,6 @@ export declare const useToast: () => {
 
 export declare const useToggle: () => readonly [boolean, () => void];
 
+declare type ValueSupportSize = 'sm' | 'lg';
+
 export { }