@tqc-solution/design-system 0.1.77 → 0.1.79

package/dist/assets/icon/IconCheckCircle.d.ts

@@ -0,0 +1,3 @@
+import type { IconProps } from "../../types";
+declare const IconCheckCircle: ({ className, width, height, color, }: IconProps) => import("react/jsx-runtime").JSX.Element;
+export default IconCheckCircle;

package/dist/assets/icon/IconCircleOutline.d.ts

@@ -0,0 +1,3 @@
+import type { IconProps } from "../../types";
+declare const IconCircleOutline: ({ className, width, height, color, }: IconProps) => import("react/jsx-runtime").JSX.Element;
+export default IconCircleOutline;

package/dist/assets/icon/IconPlus.d.ts

@@ -0,0 +1,3 @@
+import type { IconProps } from '../../types';
+declare const IconPlus: ({ className, width, height, color, }: IconProps) => import("react/jsx-runtime").JSX.Element;
+export default IconPlus;

package/dist/assets/icon/IconSmallCaretDown.d.ts

@@ -0,0 +1,3 @@
+import type { IconProps } from "../../types";
+declare const IconSmallCaretDown: ({ className, width, height, color, }: IconProps) => import("react/jsx-runtime").JSX.Element;
+export default IconSmallCaretDown;

package/dist/components/DataFilter/DataFilter.d.ts

@@ -0,0 +1,10 @@
+import { type ButtonHTMLAttributes } from 'react';
+export interface DataFilterProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'children'> {
+    /** Label text (default: "Data filter") */
+    label?: string;
+    /** Whether the chip is in selected/active state (blue border) */
+    selected?: boolean;
+    /** Additional CSS class name */
+    className?: string;
+}
+export declare const DataFilter: import("react").ForwardRefExoticComponent<DataFilterProps & import("react").RefAttributes<HTMLButtonElement>>;

package/dist/components/DataFilter/index.d.ts

@@ -0,0 +1,2 @@
+export { DataFilter } from './DataFilter';
+export type { DataFilterProps } from './DataFilter';

package/dist/components/FilterChip/FilterChip.d.ts

@@ -0,0 +1,18 @@
+import { type HTMLAttributes } from 'react';
+export interface FilterChipProps extends Omit<HTMLAttributes<HTMLSpanElement>, 'color'> {
+    /** Filter label (e.g., "Status", "Category") */
+    label?: string;
+    /** Filter value to display */
+    value: string;
+    /** Visual type of the filter chip */
+    type?: 'default' | 'filterMore';
+    /** Whether the chip is selected/active (affects border color) */
+    selected?: boolean;
+    /** Callback function when close button is clicked (filterMore type only) */
+    onClose?: () => void;
+    /** Additional CSS class name */
+    className?: string;
+    /** Count badge to display (e.g., number of items in filter). If prefixed with "+", will show as "+2" */
+    count?: number | string;
+}
+export declare const FilterChip: import("react").ForwardRefExoticComponent<FilterChipProps & import("react").RefAttributes<HTMLSpanElement>>;

package/dist/components/FilterChip/index.d.ts

@@ -0,0 +1,2 @@
+export { FilterChip } from './FilterChip';
+export type { FilterChipProps } from './FilterChip';

package/dist/components/Input/InputForm/InputForm.d.ts

@@ -1,4 +1,5 @@
 import { type InputHTMLAttributes, type TextareaHTMLAttributes, type ReactNode } from 'react';
+import { type MenuListItemData, type CategoryOptionMapping } from '../../MenuList';
 export type InputFormType = 'text' | 'textarea';
 export type HelperTextType = 'default' | 'error' | 'success' | 'disabled';
 export type HelperTextConfig = {
@@ -10,10 +11,10 @@ export type HelperTextConfig = {
     icon?: ReactNode;
 };
 type BaseInputFormProps = {
-    /** Input type: 'text' for single-line input or 'textarea' for multi-line textarea */
+    /** Input type: 'text' for single-line input, 'textarea' for multi-line textarea */
     type?: InputFormType;
-    /** Unique identifier for the input field (required for label association) */
-    id: string;
+    /** Unique identifier for the input field (optional, only needed if label is provided) */
+    id?: string;
     /** Label text displayed above the input */
     label?: string;
     /** Whether the field is required (shows asterisk) */
@@ -30,6 +31,34 @@ type BaseInputFormProps = {
     onCopy?: () => void;
     /** Additional CSS class name */
     className?: string;
+    /** Whether to show as dropdown (true) or text input (false). When true, shows dropdown with options. When false or undefined, shows regular text input. Note: textarea does not support dropdown */
+    dropdown?: boolean;
+    /** Menu items for dropdown mode */
+    items?: MenuListItemData[];
+    /** Selection mode for dropdown mode: 'single', 'multiple', or 'multipleWithMultiple' */
+    selectMode?: 'single' | 'multiple' | 'multipleWithMultiple';
+    /** Selected value(s) for dropdown mode - string for single mode, string[] for multiple mode, { categories: string[], options: string[] } for multipleWithMultiple */
+    selectValue?: string | string[] | {
+        categories: string[];
+        options: string[];
+    };
+    /** Callback when selection changes (for dropdown mode) */
+    onSelectChange?: (value: string | string[] | {
+        categories: string[];
+        options: string[];
+    }) => void;
+    /** For multipleWithMultiple mode: categories items (left column) */
+    categories?: MenuListItemData[];
+    /** For multipleWithMultiple mode: options items (right column) */
+    options?: MenuListItemData[];
+    /** For multipleWithMultiple mode: mapping between categories and their options */
+    categoryOptionMapping?: CategoryOptionMapping[];
+    /** Maximum height of dropdown menu */
+    dropdownMaxHeight?: string;
+    /** Whether dropdown is open (controlled) */
+    dropdownOpen?: boolean;
+    /** Callback when dropdown open state changes */
+    onDropdownOpenChange?: (open: boolean) => void;
 };
 type TextInputProps = BaseInputFormProps & Omit<InputHTMLAttributes<HTMLInputElement>, 'size' | 'type' | 'id'> & {
     type?: 'text';

package/dist/components/Input/InputForm/index.d.ts

@@ -1,2 +1,2 @@
 export { InputForm } from './InputForm';
-export type { InputFormProps, InputFormType } from './InputForm';
+export type { InputFormProps, InputFormType, HelperTextConfig, HelperTextType } from './InputForm';

package/dist/components/Input/InputFormSpecial/InputFormSpecial.d.ts

@@ -1,4 +1,5 @@
 import { type InputHTMLAttributes, type ReactNode, type ChangeEvent } from 'react';
+import { type MenuListItemData, type CategoryOptionMapping } from '../../MenuList';
 export declare const InputFormSpecialType: {
     readonly EMAIL: "email";
     readonly PHONE: "phone";
@@ -25,10 +26,10 @@ export type PasswordRule = {
     satisfied: boolean;
 };
 export type InputFormSpecialProps = Omit<InputHTMLAttributes<HTMLInputElement>, 'size' | 'type' | 'value' | 'onChange'> & {
-    /** Unique identifier for the input field (required for label association) */
-    id: string;
-    /** Type of special input */
-    type: InputFormSpecialType;
+    /** Unique identifier for the input field (optional, only needed if label is provided) */
+    id?: string;
+    /** Type of special input. When dropdown is true, can be any string (e.g., 'text'). When dropdown is false, must be InputFormSpecialType */
+    type: InputFormSpecialType | string;
     /** Label text displayed above the input */
     label?: string;
     /** Whether the field is required (shows asterisk) */
@@ -43,6 +44,10 @@ export type InputFormSpecialProps = Omit<InputHTMLAttributes<HTMLInputElement>,
     countryCode?: string;
     /** Callback when country code changes (for phone type) */
     onCountryCodeChange?: (code: string) => void;
+    /** Whether to show country code selector as dropdown (for phone type, default: false). When true, shows dropdown to select country code */
+    selectCountryCode?: boolean;
+    /** Country code options for dropdown selection (for phone type with selectCountryCode=true) */
+    countryCodeOptions?: MenuListItemData[];
     /** Prefix text for website type (default: 'http://') */
     websitePrefix?: string;
     /** Currency symbol for money type (default: '$') */
@@ -53,24 +58,46 @@ export type InputFormSpecialProps = Omit<InputHTMLAttributes<HTMLInputElement>,
     passwordRules?: PasswordRule[];
     /** Whether to show password toggle icon (for password type, default: true) */
     showPasswordToggle?: boolean;
-    /** Maximum number of tags to display before showing "+X" (for multiple-tag type, undefined = auto-calculate based on width) */
-    maxVisibleTags?: number;
     /** Additional CSS class name */
     className?: string;
-    /** Input value - for MULTIPLE_TAG type, can be string (comma-separated) or string[] */
-    value?: string | string[];
-    /** Callback when value changes - for MULTIPLE_TAG type, can emit string or string[] */
+    /** Input value - for MULTIPLE_TAG type, can be string (comma-separated) or string[]. For dropdown: string for single, string[] for multiple, { categories: string[], options: string[] } for multipleWithMultiple */
+    value?: string | string[] | {
+        categories: string[];
+        options: string[];
+    };
+    /** Callback when value changes - for MULTIPLE_TAG type, can emit string or string[]. For dropdown: same as value type */
     onChange?: (e: ChangeEvent<HTMLInputElement> | {
         target: {
-            value: string | string[];
+            value: string | string[] | {
+                categories: string[];
+                options: string[];
+            };
         };
     }) => void;
+    /** Whether to show as dropdown (true) or text input (false). When true, shows dropdown with options. When false or undefined, shows regular text input based on type */
+    dropdown?: boolean;
+    /** Menu items for dropdown mode */
+    items?: MenuListItemData[];
+    /** Selection mode for dropdown mode: 'single', 'multiple', or 'multipleWithMultiple' */
+    selectMode?: 'single' | 'multiple' | 'multipleWithMultiple';
+    /** Maximum height of dropdown menu */
+    dropdownMaxHeight?: string;
+    /** Whether dropdown is open (controlled) */
+    dropdownOpen?: boolean;
+    /** Callback when dropdown open state changes */
+    onDropdownOpenChange?: (open: boolean) => void;
+    /** For multipleWithMultiple mode: categories items (left column) */
+    categories?: MenuListItemData[];
+    /** For multipleWithMultiple mode: options items (right column) */
+    options?: MenuListItemData[];
+    /** For multipleWithMultiple mode: mapping between categories and their options */
+    categoryOptionMapping?: CategoryOptionMapping[];
 };
 export declare const InputFormSpecial: import("react").ForwardRefExoticComponent<Omit<InputHTMLAttributes<HTMLInputElement>, "onChange" | "size" | "value" | "type"> & {
-    /** Unique identifier for the input field (required for label association) */
-    id: string;
-    /** Type of special input */
-    type: InputFormSpecialType;
+    /** Unique identifier for the input field (optional, only needed if label is provided) */
+    id?: string;
+    /** Type of special input. When dropdown is true, can be any string (e.g., 'text'). When dropdown is false, must be InputFormSpecialType */
+    type: InputFormSpecialType | string;
     /** Label text displayed above the input */
     label?: string;
     /** Whether the field is required (shows asterisk) */
@@ -85,6 +112,10 @@ export declare const InputFormSpecial: import("react").ForwardRefExoticComponent
     countryCode?: string;
     /** Callback when country code changes (for phone type) */
     onCountryCodeChange?: (code: string) => void;
+    /** Whether to show country code selector as dropdown (for phone type, default: false). When true, shows dropdown to select country code */
+    selectCountryCode?: boolean;
+    /** Country code options for dropdown selection (for phone type with selectCountryCode=true) */
+    countryCodeOptions?: MenuListItemData[];
     /** Prefix text for website type (default: 'http://') */
     websitePrefix?: string;
     /** Currency symbol for money type (default: '$') */
@@ -95,16 +126,38 @@ export declare const InputFormSpecial: import("react").ForwardRefExoticComponent
     passwordRules?: PasswordRule[];
     /** Whether to show password toggle icon (for password type, default: true) */
     showPasswordToggle?: boolean;
-    /** Maximum number of tags to display before showing "+X" (for multiple-tag type, undefined = auto-calculate based on width) */
-    maxVisibleTags?: number;
     /** Additional CSS class name */
     className?: string;
-    /** Input value - for MULTIPLE_TAG type, can be string (comma-separated) or string[] */
-    value?: string | string[];
-    /** Callback when value changes - for MULTIPLE_TAG type, can emit string or string[] */
+    /** Input value - for MULTIPLE_TAG type, can be string (comma-separated) or string[]. For dropdown: string for single, string[] for multiple, { categories: string[], options: string[] } for multipleWithMultiple */
+    value?: string | string[] | {
+        categories: string[];
+        options: string[];
+    };
+    /** Callback when value changes - for MULTIPLE_TAG type, can emit string or string[]. For dropdown: same as value type */
     onChange?: (e: ChangeEvent<HTMLInputElement> | {
         target: {
-            value: string | string[];
+            value: string | string[] | {
+                categories: string[];
+                options: string[];
+            };
         };
     }) => void;
+    /** Whether to show as dropdown (true) or text input (false). When true, shows dropdown with options. When false or undefined, shows regular text input based on type */
+    dropdown?: boolean;
+    /** Menu items for dropdown mode */
+    items?: MenuListItemData[];
+    /** Selection mode for dropdown mode: 'single', 'multiple', or 'multipleWithMultiple' */
+    selectMode?: "single" | "multiple" | "multipleWithMultiple";
+    /** Maximum height of dropdown menu */
+    dropdownMaxHeight?: string;
+    /** Whether dropdown is open (controlled) */
+    dropdownOpen?: boolean;
+    /** Callback when dropdown open state changes */
+    onDropdownOpenChange?: (open: boolean) => void;
+    /** For multipleWithMultiple mode: categories items (left column) */
+    categories?: MenuListItemData[];
+    /** For multipleWithMultiple mode: options items (right column) */
+    options?: MenuListItemData[];
+    /** For multipleWithMultiple mode: mapping between categories and their options */
+    categoryOptionMapping?: CategoryOptionMapping[];
 } & import("react").RefAttributes<HTMLInputElement>>;

package/dist/components/Input/InputFormSpecial/index.d.ts

@@ -1,2 +1,2 @@
 export { InputFormSpecial, InputFormSpecialType } from './InputFormSpecial';
-export type { InputFormSpecialProps, HelperTextConfig, PasswordRule, } from './InputFormSpecial';
+export type { InputFormSpecialProps, HelperTextConfig, HelperTextType, PasswordRule, } from './InputFormSpecial';

package/dist/components/MenuList/FilterMenu/FilterMenu.d.ts

@@ -0,0 +1,36 @@
+import { type HTMLAttributes } from 'react';
+import type { MenuListItemData } from '../MenuList';
+export type FilterMenuMode = 'single' | 'multiple' | 'multipleCategory';
+export interface FilterMenuCategory {
+    /** Category label */
+    label: string;
+    /** Items in this category */
+    items: MenuListItemData[];
+}
+export interface FilterMenuProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange' | 'onApply'> {
+    /** Menu items (for single/multiple mode) */
+    items?: MenuListItemData[];
+    /** Items with categories (for multipleCategory mode) */
+    itemsWithCategories?: FilterMenuCategory[];
+    /** Selection mode: 'single', 'multiple', or 'multipleCategory' */
+    mode?: FilterMenuMode;
+    /** Selected value(s) - string for single mode, string[] for multiple mode */
+    value?: string | string[];
+    /** Callback when selection changes (pending state for multiple modes) */
+    onChange?: (value: string | string[]) => void;
+    /** Callback when Apply button is clicked (only for multiple and multipleCategory modes) */
+    onApply?: (value: string | string[]) => void;
+    /** Whether search is enabled */
+    searchable?: boolean;
+    /** Search placeholder */
+    searchPlaceholder?: string;
+    /** Apply button text (only for multiple and multipleCategory modes) */
+    applyButtonText?: string;
+    /** Maximum height of the menu list */
+    maxHeight?: string;
+    /** Whether this is a standalone menu (not in dropdown) */
+    standalone?: boolean;
+    /** Additional CSS class name */
+    className?: string;
+}
+export declare const FilterMenu: import("react").ForwardRefExoticComponent<FilterMenuProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/components/MenuList/FilterMenu/index.d.ts

@@ -0,0 +1,2 @@
+export { FilterMenu } from './FilterMenu.tsx';
+export type { FilterMenuProps, FilterMenuMode, FilterMenuCategory } from './FilterMenu.tsx';

package/dist/components/MenuList/MenuList.d.ts

@@ -0,0 +1,67 @@
+import { type HTMLAttributes, type ReactNode } from 'react';
+import type { TagProps } from '../Tag';
+export type MenuListMode = 'single' | 'multiple' | 'multipleWithSearch' | 'multipleWithMultiple';
+export interface MenuListItemData {
+    /** Item value */
+    value: string;
+    /** Item label */
+    label: string;
+    /** Optional supporting text */
+    supportingText?: string;
+    /** Optional left element (avatar, icon, flag, etc.) */
+    leftElement?: ReactNode;
+    /** Optional right element (tag, icon, etc.) */
+    rightElement?: ReactNode;
+    /** Tag configuration - will be displayed in rightElement position (only for multiple mode) */
+    tag?: {
+        /** Tag text content */
+        text: string;
+        /** Tag type (default: 'blue') */
+        type?: TagProps['type'];
+        /** Tag size (default: 'sm') */
+        size?: TagProps['size'];
+    };
+    /** Whether item is disabled */
+    disabled?: boolean;
+}
+export interface CategoryOptionMapping {
+    /** Category value */
+    categoryValue: string;
+    /** Options that belong to this category */
+    optionValues: string[];
+}
+export interface MenuListProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    /** Menu items (not required for multipleWithMultiple mode) */
+    items?: MenuListItemData[];
+    /** Selection mode: 'single', 'multiple', 'multipleWithSearch', or 'multipleWithMultiple' */
+    mode?: MenuListMode;
+    /** Selected value(s) - string for single mode, string[] for multiple mode. For multipleWithMultiple: { categories: string[], options: string[] } */
+    value?: string | string[] | {
+        categories: string[];
+        options: string[];
+    };
+    /** Callback when selection changes. For multipleWithMultiple: (value: { categories: string[], options: string[] }) => void */
+    onChange?: (value: string | string[] | {
+        categories: string[];
+        options: string[];
+    }) => void;
+    /** Search placeholder */
+    searchPlaceholder?: string;
+    /** Category label (shown in header when showHeader is true) */
+    categoryLabel?: string;
+    /** Custom clear button text */
+    clearButtonText?: string;
+    /** Maximum height of the menu list */
+    maxHeight?: string;
+    /** Whether this is a standalone menu (not in dropdown) */
+    standalone?: boolean;
+    /** Additional CSS class name */
+    className?: string;
+    /** For multipleWithMultiple mode: categories items (left column) */
+    categories?: MenuListItemData[];
+    /** For multipleWithMultiple mode: options items (right column) */
+    options?: MenuListItemData[];
+    /** For multipleWithMultiple mode: mapping between categories and their options */
+    categoryOptionMapping?: CategoryOptionMapping[];
+}
+export declare const MenuList: import("react").ForwardRefExoticComponent<MenuListProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/components/MenuList/MenuListItem/MenuListItem.d.ts

@@ -0,0 +1,37 @@
+import { type ReactNode } from 'react';
+import { type TagProps } from '../../Tag';
+export interface MenuListItemProps {
+    /** Item value */
+    value: string;
+    /** Item label */
+    label: string;
+    /** Optional supporting text */
+    supportingText?: string;
+    /** Optional left element (avatar/image) */
+    leftElement?: ReactNode;
+    /** Optional right element (tag - only shown in multiple mode) */
+    rightElement?: ReactNode;
+    /** Tag configuration - will be displayed in rightElement position (only for multiple mode) */
+    tag?: {
+        /** Tag text content */
+        text: string;
+        /** Tag type (default: 'blue') */
+        type?: TagProps['type'];
+        /** Tag size (default: 'sm') */
+        size?: TagProps['size'];
+    };
+    /** Whether item is disabled */
+    disabled?: boolean;
+    /** Whether item is selected */
+    selected?: boolean;
+    /** Selection mode: 'single' or 'multiple' */
+    mode?: 'single' | 'multiple';
+    /** Callback when item is clicked */
+    onClick?: (value: string) => void;
+    /** Additional CSS class name */
+    className?: string;
+}
+export declare const MenuListItem: {
+    ({ value, label, supportingText, leftElement, rightElement, tag, disabled, selected, mode, onClick, className, }: MenuListItemProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/components/MenuList/MenuListItem/index.d.ts

@@ -0,0 +1,2 @@
+export { MenuListItem } from './MenuListItem';
+export type { MenuListItemProps } from './MenuListItem';

package/dist/components/MenuList/index.d.ts

@@ -0,0 +1,6 @@
+export { MenuList } from './MenuList';
+export type { MenuListProps, MenuListMode, MenuListItemData, CategoryOptionMapping } from './MenuList';
+export { MenuListItem } from './MenuListItem';
+export type { MenuListItemProps } from './MenuListItem';
+export { FilterMenu } from './FilterMenu';
+export type { FilterMenuProps, FilterMenuMode } from './FilterMenu';

package/dist/components/Toast/Toast.d.ts

@@ -1,9 +1,15 @@
-export type ToastType = 'success' | 'error';
+import type { ToastPlacement, ToastType } from './toastStore';
+export type { ToastType };
 export interface ToastProps {
     type: ToastType;
     message: string;
     actionLabel?: string;
     onActionClick?: () => void;
+    duration?: number;
+    placement?: ToastPlacement;
+    width?: number | string;
+    className?: string;
+    onClose?: () => void;
+    onClick?: () => void;
+    style?: React.CSSProperties;
 }
-export declare const showToast: () => string;
-export declare const notification: any;

package/dist/components/Toast/ToastContainer.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const ToastContainer: React.FC;

package/dist/components/Toast/ToastItem.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { type ToastItem as ToastItemType } from './toastStore';
+interface ToastItemProps {
+    toast: ToastItemType;
+}
+export declare const ToastItem: React.FC<ToastItemProps>;
+export {};

package/dist/components/Toast/index.d.ts

@@ -1,2 +1,5 @@
-export { showToast, notification } from './Toast';
+export { showToast, closeToast, closeAllToasts } from './toastUtils';
+export { ToastContainer } from './ToastContainer';
 export type { ToastProps, ToastType } from './Toast';
+export type { ToastPlacement } from './toastStore';
+export { ensureToastContainer, removeToastContainer } from './toastContainerManager';

package/dist/components/Toast/toastContainerManager.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Đánh dấu rằng container đã được mount thủ công
+ * Ngăn không cho tự động mount
+ */
+export declare const setManualMount: () => void;
+/**
+ * Tự động mount ToastContainer vào DOM khi cần
+ * Chỉ mount một lần duy nhất, tái sử dụng cho các lần sau
+ * Không mount nếu đã được mount thủ công
+ */
+export declare const ensureToastContainer: () => void;
+/**
+ * Unmount ToastContainer (dùng cho testing hoặc cleanup)
+ */
+export declare const removeToastContainer: () => void;

package/dist/components/Toast/toastStore.d.ts

@@ -0,0 +1,29 @@
+export type ToastPlacement = 'top' | 'topLeft' | 'topRight' | 'bottom' | 'bottomLeft' | 'bottomRight';
+export type ToastType = 'success' | 'error';
+export interface ToastItem {
+    key: string;
+    type: ToastType;
+    message: string;
+    actionLabel?: string;
+    onActionClick?: () => void;
+    duration: number;
+    placement: ToastPlacement;
+    width?: number | string;
+    className?: string;
+    onClose?: () => void;
+    onClick?: () => void;
+    style?: React.CSSProperties;
+}
+type ToastListener = (toasts: ToastItem[]) => void;
+declare class ToastStore {
+    private toasts;
+    private listeners;
+    subscribe(listener: ToastListener): () => void;
+    private notify;
+    add(toast: ToastItem): string;
+    remove(key: string): void;
+    removeAll(): void;
+    getToasts(placement?: ToastPlacement): ToastItem[];
+}
+export declare const toastStore: ToastStore;
+export {};

package/dist/components/Toast/toastUtils.d.ts

@@ -0,0 +1,4 @@
+import type { ToastProps } from './Toast';
+export declare const showToast: (props: ToastProps) => string;
+export declare const closeToast: (key: string) => void;
+export declare const closeAllToasts: () => void;

package/dist/components/Tooltip/Tooltip.d.ts

@@ -1,10 +1,50 @@
-export type TooltipTheme = 'light' | 'dark';
-export interface TooltipProps {
-    title: any;
-    supportText?: any;
+import { type ReactNode } from "react";
+export type TooltipTheme = "light" | "dark";
+export type TooltipPlacement = "top" | "bottom" | "left" | "right" | "topLeft" | "topRight";
+export type TooltipTrigger = "hover" | "click" | Array<"hover" | "click">;
+export interface TooltipProps extends Omit<React.HTMLAttributes<HTMLElement>, 'title'> {
+    /**
+     * The main title content to display in the tooltip
+     */
+    title: ReactNode;
+    /**
+     * Optional support text (description) to display below the title
+     */
+    supportText?: ReactNode;
+    /**
+     * The theme of the tooltip (light or dark)
+     * @default 'dark'
+     */
     theme?: TooltipTheme;
-    children: any;
+    /**
+     * The element that triggers the tooltip
+     */
+    children: ReactNode;
+    /**
+     * Additional CSS class name for custom styling
+     */
     className?: string;
+    /**
+     * Whether to show arrow
+     * @default true
+     */
     arrow?: boolean;
+    /**
+     * The position of the tooltip relative to the target element
+     * @default 'top'
+     */
+    placement?: TooltipPlacement;
+    /**
+     * The trigger mode which executes the tooltip
+     * @default 'hover'
+     */
+    trigger?: TooltipTrigger;
+    /**
+     * z-index of tooltip
+     */
+    zIndex?: number;
 }
-export declare const Tooltip: () => null;
+export declare const Tooltip: {
+    ({ title, supportText, theme, children, className, arrow, placement, trigger, zIndex, }: TooltipProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/components/Tooltip/index.d.ts

@@ -1,2 +1,2 @@
 export { Tooltip } from './Tooltip';
-export type { TooltipProps, TooltipTheme } from './Tooltip';
+export type { TooltipProps, TooltipTheme, TooltipPlacement, TooltipTrigger } from './Tooltip';