@tanishraj/ui-kit 2.4.1 → 2.5.2

package/dist/index.d.ts

@@ -1,23 +1,39 @@
+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';
 import { ClassValue } from 'clsx';
+import { ComponentProps } from 'react';
 import { ComponentPropsWithoutRef } from 'react';
 import { ComponentPropsWithRef } from 'react';
+import { CreatableProps } from 'react-select/creatable';
+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 { HTMLProps } from 'react';
+import { ITooltip } from 'react-tooltip';
+import { JSX } 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 { 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 +45,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 +58,24 @@ 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 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>> {
+export declare interface AlertProps extends RemoveNull<VariantProps<typeof alertWrapperStyles>> {
     title?: string;
     icon?: FC<SVGProps<SVGSVGElement>>;
     children?: ReactNode;
     onClose?: () => void;
 }
 
-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;
@@ -77,6 +93,13 @@ declare interface AnimatePresenceProps {
     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 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'> {
+    isDisabled?: boolean;
+    options?: Options<Option>;
+}
+
 export declare const Avatar: FC<AvatarProps>;
 
 declare const avatarContainerStyles: (props?: ({
@@ -101,9 +124,9 @@ 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>>;
 
@@ -125,11 +148,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,21 +163,21 @@ 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 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 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;
@@ -167,7 +190,7 @@ declare const badgeVariants: (props?: ({
 
 export declare const Breadcrumb: FC<BreadcrumbProps>;
 
-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'> {
     id?: string;
@@ -191,7 +214,7 @@ declare const breadcrumbStyles: (props?: ({
 
 export declare const Button: FC<ButtonProps>;
 
-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>;
 
@@ -218,9 +241,9 @@ export declare interface ButtonProps extends ComponentPropsWithRef<'button'>, Re
     trailingIcon?: FC<SVGProps<SVGSVGElement>>;
 }
 
-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;
@@ -233,7 +256,7 @@ declare const buttonStyles: (props?: ({
     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>;
 
@@ -280,15 +303,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, ...restProps }: CheckboxSelectProps<Option, IsMulti>) => JSX.Element;
+
+export declare interface CheckboxSelectProps<Option extends SelectOption = SelectOption, IsMulti extends boolean = false> extends SelectProps<Option, IsMulti> {
+    compactDisplay?: boolean;
+}
+
+export declare type CheckboxShapes = RemoveNull<VariantProps<typeof checkboxControlStyles>>['shape'];
 
-export declare type CheckboxSizes = RemoveNull_2<VariantProps<typeof checkboxControlStyles>>['size'];
+export declare type CheckboxSizes = RemoveNull<VariantProps<typeof checkboxControlStyles>>['size'];
 
 export declare const Chip: FC<ChipProps>;
 
 export declare type ChipIcon = FC<SVGProps<SVGSVGElement>>;
 
-export declare interface ChipProps extends Omit<ComponentPropsWithoutRef<'span'>, 'children'>, RemoveNull_2<Omit<VariantProps<typeof chipStyles>, 'disabled' | 'hasLeadingVisual' | 'removable'>> {
+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 +325,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,13 +340,88 @@ 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 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 const ConfirmationPopup: FC<ConfirmationPopupProps>;
+
+export declare type ConfirmationPopupAlignments = 'start' | 'center' | 'end';
+
+export declare type ConfirmationPopupIcon = FC<SVGProps<SVGSVGElement>>;
+
+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 ConfirmationPopupProps extends Omit<HTMLAttributes<HTMLDivElement>, '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;
+    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 const CountryFlag: FC<CountryFlagProps>;
+
+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 const Divider: FC<DividerProps>;
 
-export declare type DividerOrientations = RemoveNull_2<VariantProps<typeof dividerRootStyles>>['orientation'];
+export declare type DividerOrientations = RemoveNull<VariantProps<typeof dividerRootStyles>>['orientation'];
 
 export declare interface DividerProps extends HTMLAttributes<HTMLDivElement> {
     children?: ReactNode;
@@ -336,9 +440,9 @@ declare const drawerPanelStyles: (props?: ({
     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<HTMLAttributes<HTMLDivElement>, 'title'>, RemoveNull<VariantProps<typeof drawerPanelStyles>> {
     open: boolean;
     children?: ReactNode;
     title?: ReactNode;
@@ -356,7 +460,7 @@ 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>;
 
@@ -414,6 +518,12 @@ declare enum EThemeOptions {
     DARK = "dark"
 }
 
+export declare enum ETrend {
+    positive = "positive",
+    negative = "negative",
+    neutral = "neutral"
+}
+
 export declare const Feedback: FC<FeedbackProps>;
 
 export declare type FeedbackGetLabelText = (option: FeedbackOption, index: number, total: number) => string;
@@ -442,10 +552,97 @@ 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 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 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 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<unknown>;
+    required?: boolean;
+    size?: SelectSizes;
+    styles?: ComponentProps<typeof default_2<Option, true>>['styles'];
+    value?: MultiValue<Option>;
+    variant?: SelectVariants;
+}
+
+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 interface IMetricValue {
+    color?: TMetricCardColorVariant;
+    supportText?: ReactNode;
+    supportTextSize?: TValueSupportSize;
+    text?: ReactNode;
+    trend?: ETrend;
+    trendInverted?: boolean;
+}
+
+export declare interface IMetricValueItem {
+    hint?: IMetricHint;
+    value?: IMetricValue;
+}
+
+export declare type IndicatorMapper = Record<ETrend, FC>;
+
 export declare const Input: FC<InputProps>;
 
 export declare type InputIcon = FC<SVGProps<SVGSVGElement>>;
@@ -485,11 +682,36 @@ export declare interface InternalTabProps extends TabProps {
     selected?: boolean;
 }
 
+declare type ItemType = PrimitiveValue | ObjectItem;
+
+export declare type ITrendIndicatorProps = TrendIndicatorProps;
+
+export declare const Label: FC<LabelProps>;
+
+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 const Link: FC<LinkProps>;
 
 export declare type LinkIcon = FC<SVGProps<SVGSVGElement>>;
 
-export declare interface LinkProps extends Omit<ComponentPropsWithRef<'a'>, 'children'>, RemoveNull_2<Omit<VariantProps<typeof linkStyles>, 'disabled' | 'truncate'>> {
+export declare interface LinkProps extends Omit<ComponentPropsWithRef<'a'>, 'children'>, RemoveNull<Omit<VariantProps<typeof linkStyles>, 'disabled' | 'truncate'>> {
     children: ReactNode;
     leadingIcon?: LinkIcon;
     trailingIcon?: LinkIcon;
@@ -498,7 +720,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,9 +731,9 @@ 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>>;
 
@@ -548,6 +770,10 @@ export declare interface ListItemProps extends Omit<ComponentPropsWithoutRef<'bu
 
 export declare const mergeRefs: <T>(...refs: Array<PossibleRef<T>>) => (node: T | null) => (() => void) | undefined;
 
+export declare const MetricCard: FC<IMetricCardProps>;
+
+export declare const MetricValueItem: FC<IMetricValueItem>;
+
 export declare const Modal: FC<ModalProps>;
 
 export declare type ModalIcon = FC<SVGProps<SVGSVGElement>>;
@@ -556,7 +782,7 @@ 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 +801,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>>;
 
@@ -659,7 +891,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 +910,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 +928,11 @@ declare interface PresenceChildProps {
     children: ReactElement;
 }
 
+declare type PrimitiveValue = string | number | boolean | bigint | symbol | null | undefined;
+
 export declare const ProgressBar: FC<ProgressBarProps>;
 
-export declare type ProgressBarAppearances = NonNullable<RemoveNull_2<VariantProps<typeof progressBarRootStyles>>['appearance']>;
+export declare type ProgressBarAppearances = NonNullable<RemoveNull<VariantProps<typeof progressBarRootStyles>>['appearance']>;
 
 export declare interface ProgressBarProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
     appearance?: ProgressBarAppearances;
@@ -726,7 +960,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;
@@ -780,7 +1014,7 @@ 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>;
 
@@ -799,7 +1033,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 +1043,53 @@ 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 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'> {
+    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 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 interface SelectWithApplyProps<Option extends SelectOption = SelectOption, IsMulti extends boolean = false> extends SelectProps<Option, IsMulti> {
+    allOptionLabel?: string;
+    applyButtonLabel?: string;
+    compactDisplay?: boolean;
+}
+
 export declare const Slider: FC<SliderProps>;
 
-export declare type SliderLabelSizes = RemoveNull_2<VariantProps<typeof sliderLabelStyles>>['size'];
+export declare type SliderLabelSizes = RemoveNull<VariantProps<typeof sliderLabelStyles>>['size'];
 
 declare const sliderLabelStyles: (props?: ({
     size?: "sm" | "md" | "lg" | null | undefined;
@@ -842,7 +1120,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 +1128,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;
@@ -868,6 +1146,77 @@ export declare const Tab: FC<InternalTabProps>;
 
 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;
+}
+
+export declare type TableSizes = InputSizes;
+
 declare const tabListStyles: (props?: ({
     orientation?: "horizontal" | "vertical" | null | undefined;
     variant?: "underline" | "pill" | null | undefined;
@@ -875,7 +1224,7 @@ declare const tabListStyles: (props?: ({
 
 export declare const TabPanel: FC<TabPanelProps>;
 
-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;
@@ -931,7 +1280,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,15 +1294,35 @@ 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<VariantProps<typeof tabRootStyles>>['variant'];
+
+export declare const TextArea: FC<TextAreaProps>;
+
+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 TabsVariant = RemoveNull_2<VariantProps<typeof tabRootStyles>>['variant'];
+export declare type TMetricCardColorVariant = 'secondary' | 'warning' | 'success' | 'error';
 
 export declare const Toaster: FC<ToasterProps>;
 
@@ -963,6 +1332,46 @@ export declare interface ToastProps extends AlertProps {
     dismissable?: boolean;
 }
 
+export declare const Tooltip: ForwardRefExoticComponent<Omit<TooltipProps, "ref"> & RefAttributes<TooltipRefProps>>;
+
+export declare interface TooltipProps extends Omit<ITooltip, 'variant'> {
+    variant?: 'primary' | 'secondary';
+    ref?: Ref<TooltipRefProps>;
+}
+
+export declare const TREND_INDICATOR_COLORS: {
+    positive: string;
+    negative: string;
+    neutral: string;
+};
+
+export declare const TrendIndicator: FC<TrendIndicatorProps>;
+
+export declare const trendIndicatorColors: {
+    positive: string;
+    negative: string;
+    neutral: string;
+};
+
+export declare interface TrendIndicatorProps {
+    className?: HTMLProps<HTMLElement>['className'];
+    colorizeValueText?: boolean;
+    inverted?: boolean | undefined;
+    label?: ReactNode;
+    size?: TrendIndicatorSize;
+    strokeWidth?: TrendIndicatorStrokeWidth;
+    value?: ReactNode;
+    variant?: ETrend;
+}
+
+export declare type TrendIndicatorSize = 'sm' | 'md' | 'lg';
+
+export declare type TrendIndicatorStrokeWidth = 'thin' | 'thick' | 'thicker';
+
+export declare type TTrendPosition = 'left' | 'right';
+
+export declare type TValueSupportSize = 'sm' | 'lg';
+
 export declare const useTheme: () => {
     theme: EThemeOptions;
     isDark: boolean;