import * as react_jsx_runtime from 'react/jsx-runtime';
import * as React$1 from 'react';
import React__default, { ReactNode, ChangeEvent, CSSProperties } from 'react';

interface ButtonProps {
    /**
     * Variant of the button
     */
    variant: 'primary' | 'secondary' | 'danger' | 'success';
    /**
     * What background color to use
     */
    backgroundColor?: string;
    /**
     * How large should the button be?
     */
    size?: 'small' | 'medium' | 'large';
    /**
     * Button contents
     */
    label?: string;
    /**
     * Type of the button
     */
    type?: 'button' | 'submit';
    disabled?: boolean;
    /**
     * Optional click handler
     */
    onClick?: (event: React__default.MouseEvent<HTMLButtonElement, MouseEvent>) => void;
    /**
     * Button content
     */
    children?: ReactNode;
    /**
     * Button id
     */
    id?: string;
    /**
     * onSubmit function handler
     */
    onSubmit?: (event: React__default.MouseEvent<HTMLButtonElement, MouseEvent>) => void;
    /**
     * react ref for the button
     */
    ref?: any;
    /**
     * Classname for the button
     */
    className?: string;
    /**
     * Additional styles for the button
     */
    style?: React__default.CSSProperties;
    /**
     * Pass true for transparentBackground button
     */
    transparentBackground?: boolean;
    /**
     * Pass true if button should be with icon
     */
    withIcon?: boolean;
    /**
     * Give icon name availble in storybook that to be on left side of button
     */
    iconName?: string;
    /**
     * Give icon name availble in storybook that to be on left side of button
     */
    iconPosition?: 'left' | 'right';
}
/**
 * Primary UI component for user interaction
 */
declare const Button: ({ variant, backgroundColor, size, onClick, label, disabled, children, type, className, style, transparentBackground, withIcon, iconName, iconPosition, ...props }: ButtonProps) => react_jsx_runtime.JSX.Element;

interface IconProps {
    name: string;
    className?: string;
    height?: number;
    width?: number;
    color?: string;
    onClick?: (data?: any) => void;
    hoverEffect?: boolean;
    disabled?: boolean;
    hoverFill?: boolean;
}
declare const Icon: ({ name, height, width, onClick, color, hoverEffect, className, disabled, hoverFill, ...props }: IconProps) => react_jsx_runtime.JSX.Element | null | undefined;

interface LabelProps extends React__default.LabelHTMLAttributes<HTMLLabelElement> {
    /**
     * Label text
     */
    label: string | React__default.ReactNode;
    /**
     * Label color
     */
    color?: 'default' | 'primary' | 'info' | 'danger' | 'success' | 'warning' | 'number' | 'approved' | 'review' | 'rejected' | 'new';
    /**
     * Label size
     */
    size?: 'xx-small' | 'x-small' | 'small' | 'medium' | 'large';
    /**
     * Label styles
     */
    className?: string;
    /**
     * If true adds the astrisk at the begining
     */
    required?: boolean;
}
/**
 * Label UI component
 */
declare const Label: ({ label, color, size, className, required, ...props }: LabelProps) => react_jsx_runtime.JSX.Element;

interface Option$2 {
    label: string;
    value: string;
    disabled?: boolean;
}
interface SelectProps {
    /**
     * Label properties
     */
    labelProps?: LabelProps;
    /**
     * Label properties
     */
    variant?: 'default' | 'approved' | 'review' | 'rejected';
    /**
     * If true, Field label will be displayed else it will be hidden
     */
    showLabel?: boolean;
    /**
     * Error | If true, error styles are applied
     */
    error?: boolean;
    /**
     * Disabled | If true, disabled styles are applied and field becomes non interactive
     */
    disabled?: boolean;
    /**
     * showBorder | If true, border will be added to select-box
     */
    showBorder?: boolean;
    /**
     * showBorderOnHover | If true, border will be added to select-box on hover
     */
    showBorderOnHover?: boolean;
    /**
     * SelectBox classes
     */
    className?: string;
    /**
     * If error is true, this message will be displayed
     */
    errorMsg?: string;
    /**
     * Options for the dropdown
     */
    options: Option$2[] | [];
    /**
     * Seleceted Option
     */
    selectedOption?: Option$2;
    /**
     * Placeholder | when the field is empty this will be displayed inside select box
     */
    placeholder: string;
    /**
     * on change handler
     */
    onChange?: (option: Option$2) => void;
    optionZindex?: string | number;
}
declare const Select: ({ options, selectedOption, placeholder, labelProps, disabled, className, errorMsg, error, onChange, showLabel, showBorder, showBorderOnHover, optionZindex, variant, ...props }: SelectProps) => react_jsx_runtime.JSX.Element;

interface Props$1 {
    type: 'PieChart' | 'BarChart';
    chartData: {
        datasets: {
            data: number[];
            backgroundColor: string[];
            toolTipMailArray: string[];
            userLegendMailArray: string[];
            count: number[];
        }[];
        labels: string[];
    };
    legendHeight: string;
    legendTitle: string;
    legendSubtitle: string;
    legendTitleColor: string;
    chartSize: string;
    legend: boolean;
    legendSubTitleValue: number;
    centerText: boolean;
    legeContainerWidth: string;
    chartHeight: string;
    chartWidth: string;
    toolTipText: string;
    isLegendUser: boolean;
    xAxisLabel: string;
    yAxisLabel: string;
}
declare const Chart: ({ type, chartData, legend, legendSubTitleValue, legendHeight, legendTitle, legendTitleColor, legendSubtitle, chartSize, centerText, legeContainerWidth, chartHeight, chartWidth, toolTipText, isLegendUser, xAxisLabel, yAxisLabel, }: Props$1) => react_jsx_runtime.JSX.Element;

interface TextAreaProps extends React__default.TextareaHTMLAttributes<HTMLTextAreaElement> {
    variant?: 'default' | 'success' | 'danger' | 'controlled';
    capacity?: number;
    labelProps?: LabelProps;
    error?: string;
    requiredMessage?: string;
    value?: string;
    rows?: number;
    cols?: number;
    resize?: boolean;
}
declare const TextArea: React__default.FC<TextAreaProps>;

interface PopupProps {
    /**
     * Popup to open
     */
    isOpen: boolean;
    /**
     * Type of Popup eg: success | warning | info | danger
     */
    type: string;
    /**
     * Header Title
     */
    headerTitle: string;
    /**
     * Text beside Header Title
     */
    headerText: string;
    /**
     * Continue button text
     */
    continueButtonLabel: string;
    /**
     * Cancel button text
     */
    cancelButtonLabel: string;
    /**
     * Continue button to disable or not
     */
    continueButtonDisable: boolean;
    /**
     * Cancel button to disable or not
     */
    cancelButtonDisable: boolean;
    /**
     * Event for Continue button
     */
    onContinueClick: () => void;
    /**
     * Event for Cancel button
     */
    onCancelClick: () => void;
    /**
     * Actual content to be shown in popup, eg: warning message or success
     */
    children?: ReactNode;
    /**
     * Footer content to be shown in popup, eg: Buttons or text
     */
    footerContent?: ReactNode;
}
/**
 * Popup component
 */
declare const Popup: ({ isOpen, type, headerTitle, headerText, continueButtonLabel, cancelButtonLabel, continueButtonDisable, cancelButtonDisable, onContinueClick, onCancelClick, children, footerContent, }: PopupProps) => React__default.ReactPortal | null;

interface ChipsProps {
    label: string;
    variant?: 'default' | 'primary' | 'success' | 'error' | 'warning' | 'caution';
    size?: 'container-count' | 'small' | 'medium' | 'single-count';
    hoverText?: string;
    withBackground?: boolean;
    withWhiteBackground?: boolean;
}
declare const Chip: ({ label, hoverText, variant, size, withBackground, withWhiteBackground, }: ChipsProps) => react_jsx_runtime.JSX.Element;

interface BtnPropsCommon {
    /**
     * Label for the button
     */
    label?: string;
    /**
     * Boolean value to disable the button
     */
    disabled?: boolean;
    /**
     * Onclick function for button
     */
    onClick?: () => void;
}
interface DrawerProps {
    /**
     * To Open the Drawer
     */
    isOpen: boolean;
    /**
     * Function to close the drawer
     */
    onClose?: () => void;
    /**
     * Size of the drawer medium = 550px large = 850px
     */
    size?: 'medium' | 'large';
    /**
     * Body Content of the drawer
     */
    children: ReactNode;
    /**
     * Header title for the drawer
     */
    title: string | ReactNode;
    /**
     * To show the edit button on the header
     */
    showEditButton?: boolean;
    /**
     * Primary | Success button props
     */
    primaryButtonProps?: BtnPropsCommon;
    /**
     * Secondary | Cancel button props
     */
    secondaryButtonProps?: BtnPropsCommon;
    /**
     * Onclick function for edit button
     */
    onEdit?: () => void;
    /**
     * Background overlay for the drawer
     */
    overlay?: boolean;
    /**
     * displays footer if its true, default true
     */
    isFooterRequired?: boolean;
    /**
     * footer Content
     */
    footerContent?: ReactNode;
    /**
     * Removes default padding applied for the drawer content, if given true
     */
    paddingNotRequired?: boolean;
}

declare const Drawer: ({ isOpen, children, onClose, title, primaryButtonProps, secondaryButtonProps, showEditButton, onEdit, overlay, isFooterRequired, footerContent, paddingNotRequired, size, }: DrawerProps) => React$1.ReactPortal | null;

interface DataProps$1 {
    /**
     * data for each row
     */
    [key: string]: any;
}
interface SelectedItemProps {
    /**
     * selected row object | All selected flag
     */
    [key: string]: string | number | boolean;
}
interface TableProps$1 {
    /**
     * Data for table
     */
    data: Array<number | string | DataProps$1>;
    /**
     * Column details for table
     */
    columns: Array<any>;
    /**
     * Header type to have different background color
     */
    headerType: 'default' | 'primary' | 'secondary';
    /**
     * withFixedHeader prop to have non-scrollable fixed table header
     */
    withFixedHeader?: boolean;
    /**
     * borderWithRadius prop to have table with border 1px and borderRadius 5px
     */
    borderWithRadius?: boolean;
    /**
     * Check box feature to select the row
     */
    withCheckbox?: boolean;
    /**
     * Event for checkbox onClick
     */
    onSelect?: (e: object, arg: SelectedItemProps) => void;
    /**
     * Check box feature to select the row
     */
    allSelected?: boolean;
    /**
     * send true to show partial checkbox in the header
     */
    partialSelected?: boolean;
    /**
     * send true to disable the checkbox in the header
     */
    headerCheckboxDisabled?: boolean;
    /**
     * The content that to be displayed if no data not found
     */
    noDataContent: string | ReactNode;
    /**
     * Image that to be displayed if you don't have data
     */
    noDataImage?: string;
    /**
     * Size of the image that to be displayed if you don't have data
     */
    noDataImageSize?: 'x-large' | 'large' | 'medium' | 'small' | 'x-small';
    /**
     *  Height of the table in string
     */
    height?: string;
    /**
     *  classNames for the table container
     */
    className?: string;
}
declare const Table: ({ data, columns, headerType, withCheckbox, onSelect, allSelected, partialSelected, withFixedHeader, borderWithRadius, headerCheckboxDisabled, noDataContent, noDataImage, noDataImageSize, height, className, }: TableProps$1) => react_jsx_runtime.JSX.Element | null;

interface ToggleProps {
    /**
     * Optional onChange handler
     */
    onChange?: (event: React__default.MouseEvent<HTMLInputElement, MouseEvent>) => void;
    /**
     * Is this the principal call to action on the page?
     */
    type?: 'default' | 'withLabel' | 'withIcon' | 'controlled';
    /**
     * What background color to occur upon toggled
     */
    variant?: 'primary' | 'success' | 'danger';
    /**
     * Toggle contents if its type='with_label'
     */
    enableLabel?: string;
    disableLabel?: string;
    /**
     * Toggle contents if its type='with_icon'
     */
    enableIcon?: string;
    disableIcon?: string;
    /**
     * Optional disabled prop
     */
    disabled?: boolean;
    /**
     * Optional checked prop
     */
    checked?: boolean;
    id?: string;
    /**
     * Optional background transparent prop
     */
    isBackgroundTransparent?: boolean;
    /**
     * if you want label as adjacent
     */
    label?: string;
}
declare const Toggle: React__default.FC<ToggleProps>;

interface InputProps {
    /**
     * Name | Name of the input field
     */
    name: string;
    /**
     * Label | field label to be displayed
     */
    label: string;
    /**
     * value | input field value
     */
    value: string | number;
    /**
     * varients to set color/style of the input field
     */
    variant?: 'default' | 'primary' | 'info' | 'danger' | 'success' | 'warning';
    /**
     * type to set color/style of the input field
     */
    type: 'text' | 'password' | 'number' | 'email' | 'url' | 'time';
    /**
     * size | size of the input label text
     */
    size?: 'x-small' | 'small' | 'medium' | 'large';
    /**
     * error | If true, error message will be displayed
     */
    error?: boolean;
    /**
     * helperText | error, success, warning message to be shown
     */
    helperText?: string;
    /**
     * if true, error message icon will be displayed else it will be hidden
     */
    showMessageIcon?: boolean;
    /**
     * to disable the input field
     */
    disabled?: boolean;
    /**
     * if true, input field will be mandatory
     */
    required?: boolean;
    /**
     * placeholder for the input field
     */
    placeholder?: string;
    /**
     * classnames to style the input field
     */
    className?: string;
    /**
     * onchange action
     */
    onChange?: (event: ChangeEvent<HTMLInputElement>) => void;
    onKeyDown?: (event: React__default.KeyboardEvent<HTMLInputElement>) => void;
    id?: string;
    style?: React__default.CSSProperties;
    /**
     * if on, suggestion popup will be displayed
     */
    autoComplete?: 'on' | 'off';
    /**
     *  minimum and maximum values for the number type input field and their functions
     */
    minValue?: number;
    maxValue?: number;
    setValue?: (newValue: string) => void;
    /**
     * background of the input field prop
     */
    isBackgroundTransparent?: boolean;
}
declare const Input: ({ type, variant, name, size, label, disabled, required, placeholder, value, helperText, error, showMessageIcon, className, onChange, autoComplete, minValue, maxValue, setValue, isBackgroundTransparent, ...props }: InputProps) => react_jsx_runtime.JSX.Element;

interface Props {
    /**
     * Optional side label
     */
    label?: string;
    /**
     * Optional disable attribute
     */
    disabled?: boolean;
    /**
     *Optional checked attribute to prefill
     */
    checked?: boolean;
    /**
     * Value as a prop if any
     */
    value?: string;
    /**
     * Optional onChange function
     */
    onChange?: (event: React__default.ChangeEvent<HTMLInputElement>) => void;
    style?: CSSProperties;
    /**
     * for partial checked checkbox
     */
    partial?: boolean;
}
declare const Checkbox: (props: Props) => react_jsx_runtime.JSX.Element;

interface Option$1 {
    label: string | React.ReactNode;
    value: Array<string> | string;
    chipText?: string;
    disable?: boolean;
}
interface MenuOptionProps {
    labelName?: string | React.ReactNode;
    /**
     * default icon to be display
     */
    iconName: string;
    options: Array<Option$1>;
    /**
     * if true displays chip
     */
    isChipRequired?: boolean;
    chipSize?: 'small' | 'medium';
    /**
     * tooltip title
     */
    tooltipTitle: string;
    placement: 'bottom' | 'left' | 'right' | 'top';
    onClick?: () => void;
    onOptionClick?: (data?: any) => void;
    disabled?: boolean;
}
declare const MenuOption: ({ labelName, iconName, options, isChipRequired, chipSize, tooltipTitle, placement, onClick, onOptionClick, disabled, }: MenuOptionProps) => react_jsx_runtime.JSX.Element;

interface ToasterProps {
    /**
     * toaster to open
     */
    isOpen: boolean;
    /**
     * Type of toaster eg: success | warning | info | danger
     */
    variant: 'success' | 'warning' | 'danger' | 'info';
    /**
     * Options for where to show toaster
     */
    displayPosition: 'top' | 'bottom' | 'top-right' | 'bottom-right' | 'top-left' | 'bottom-left';
    /**
     * Header Title
     */
    toastTitle: string;
    /**
     * Actual content to be shown in toaster, eg: warning toastMessage or success
     */
    toastMessage?: string;
    /**
     * Event for Cancel button
     */
    onCancelClick?: () => void;
    /**
     * Event for Cancel button
     */
    onMouseOverOnButton?: () => void;
    /**
     * Number of milliseconds Toaster need to display
     */
    displayDuration?: number;
    /**
     * label for close button
     */
    closeButtonLabel?: React__default.ReactNode;
}
declare const Toaster: React__default.FC<ToasterProps>;

interface ColumnDataProps {
    name: string;
    accessor: string;
    width: string;
    isClickable?: boolean;
}
interface ObjectProps {
    [key: string]: any;
}
interface TableTreeProps {
    withCheckBox: boolean;
    columnsData: Array<ColumnDataProps>;
    treeData: Array<ObjectProps>;
    onClick?: (event: React.MouseEvent<HTMLDivElement, MouseEvent>, data: any) => void;
}
declare const TableTree: ({ withCheckBox, columnsData, treeData, onClick, }: TableTreeProps) => react_jsx_runtime.JSX.Element;

interface HistoryCardProps {
    /**
     * Is this the principal call to action on the page?
     */
    variant: 'primary' | 'secondary' | 'danger' | 'success' | 'warning';
    /**
     * Details to display the title
     */
    title: any;
    /**
     * State of the approval entity
     */
    state: 'approved' | 'rejected' | 'review';
    /**
     * Version of the approval entity
     */
    version: string | number;
    /**
     * Comment message to display on the history card
     */
    comment: string;
    /**
     * profileShortName is to display short name inside the profile avatar
     */
    profileShortName: string;
}
declare const HistoryCard: ({ variant, title, state, comment, profileShortName, version, ...props }: HistoryCardProps) => react_jsx_runtime.JSX.Element;

interface CardProps {
    header?: boolean;
    footer?: boolean;
    title?: string;
    footerContent?: any;
    variant: 'default' | 'primary' | 'success' | 'warning' | 'error';
    rounded?: boolean;
    shadow?: boolean;
    paddingRequired?: boolean;
    size?: 'x-small' | 'small' | 'medium' | 'large';
    classnames?: any;
    contentXPosition?: 'start' | 'center' | 'end';
    contentYPosition?: 'top' | 'center' | 'bottom';
    headerClasses?: '';
    contentClasses?: '';
    footerClasses?: '';
    children?: any;
}
/**
 * *__header__* : Boolean to show/hide header | optional | default is 'true'
 * *__footer__* : Boolean to show/hide footer | optional | default is 'true'
 * *__title__* : title of the card | optional
 * *__type__* : type of the card theme | default is 'primary'
 * *__rounded__* : Boolean to control card border radius | optional | default is 'false'
 * *__shadow__* : Boolean to control card shadow | optional | default is 'false'
 * *__paddingRequired__* : Boolean to control card content padding | optional
 * *__size__* : size of the header text | optional | default is 'small'
 * *__classnames__* : classnames to custom style the card | optional
 * *__contentXPosition__* : card content's horizontal position | optional | default is 'center' : 'start' | 'center' | 'end';
 * *__contentYPosition__* : card content's vertical position | optional | default is 'center' : 'top' | 'center' | 'bottom';
 * *__headerClasses__* : css classes for card header | optional
 * *__contentClasses__* : css classes for card content | optional
 * *__footerClasses__* : css classes for card footer | optional
 */
declare const Card: ({ variant, header, footer, title, size, rounded, shadow, paddingRequired, contentXPosition, contentYPosition, headerClasses, contentClasses, footerClasses, children, footerContent, }: CardProps) => react_jsx_runtime.JSX.Element;

interface IconCardProps {
    /**
     * iconName | name of the icon to be displayed on top
     */
    iconName: string;
    /**
     * title | title to be displayed for the card
     */
    title: string;
    /**
     * size | size of the card | Icon size will be adjusted automatically
     */
    size?: 'x-small' | 'small' | 'medium' | 'large';
    children?: any;
}
declare const IconCard: ({ iconName, title, size, children, }: IconCardProps) => react_jsx_runtime.JSX.Element;

interface LabelCardProps {
    /**
     * label | label to be displayed on top of the card
     */
    label: string;
    /**
     * title | title of the card
     */
    title: string;
    /**
     * type | type of the card
     */
    variant?: 'default' | 'primary' | 'success' | 'warning' | 'error';
    size?: 'x-small' | 'small' | 'medium' | 'large' | 'x-large';
    children?: any;
}
declare const LabelCard: ({ variant, label, size, title, children, }: LabelCardProps) => react_jsx_runtime.JSX.Element;

interface LoaderProps {
    /**
     * variant | variant of the loader
     */
    variant?: 'BouncingDots' | 'BlinkingDotsLoader';
}
declare const Loader: ({ variant }: LoaderProps) => react_jsx_runtime.JSX.Element;

interface AccordionProps {
    /**
     * Accordion Header Title
     */
    headerTitle: string;
    /**
     * Content that to be shown while Accordion is expanded
     */
    accordionContent: ReactNode;
    /**
     * Accordion Type
     */
    variant: 'primary' | 'secondary' | 'minimal';
    /**
     * Property to disable accordion
     */
    disable?: boolean;
    /**
     * Info message to user for disabling accordion
     */
    disableInfoMessage?: string;
    defaultState?: boolean;
}
/**
 * Accordion UI component
 */
declare const Accordion: ({ headerTitle, variant, accordionContent, disable, disableInfoMessage, defaultState, }: AccordionProps) => react_jsx_runtime.JSX.Element;

interface ColumnProps {
    /**
     * column name
     */
    header: string;
    /**
     * data key for particular column
     */
    accessor: string;
    /**
     * className for a column
     */
    className?: string;
    /**
     * width of a column
     */
    width?: number;
    /**
     * data for the column
     */
    cell?: (e: any) => JSX.Element | string | ReactNode;
}
interface DataProps {
    /**
     * data for each row
     */
    [key: string]: any;
}
interface TableProps {
    /**
     * Column details for table
     */
    tableMeta: Array<ColumnProps>;
    /**
     * Data for table
     */
    tableData: Array<DataProps>;
    /**
     * Table type
     */
    accordionType: 'row' | 'column';
    /**
     *  Specific sentence to be displayed data not found
     */
    noDataText?: string;
    /**
     * Size of the image that to be displayed if you don't have data
     */
    noDataImageSize?: 'x-large' | 'large' | 'medium' | 'small' | 'x-small';
    /**
     * Header type
     */
    variant: 'primary' | 'secondary';
    /**
     * withFixedHeader prop to have non-scrollable fixed accordion table header
     */
    withFixedHeader?: boolean;
    /**
     *  Height of the table in string
     */
    height?: string;
    /**
     * Header type to have different background color
     */
    headerType: 'default' | 'primary' | 'secondary';
}
declare const TableWithAccordion: ({ tableMeta, tableData, accordionType, noDataText, noDataImageSize, variant, height, withFixedHeader, headerType, }: TableProps) => react_jsx_runtime.JSX.Element;

interface TooltipProps {
    title: string;
    children: React__default.ReactNode;
    placement?: 'bottom' | 'left' | 'right' | 'top' | 'top-start' | 'top-end' | 'bottom-start' | 'bottom-end';
    disabled?: boolean;
}
declare const Tooltip: React__default.FC<TooltipProps>;

interface RadioButtonProps {
    /**
     * Optional Specifies the unique identifier for the radio button.
     */
    id?: string;
    /**
     * Optional Text that appears next to the radio button,
     */
    label?: string;
    /**
     * Optional The name associated with the radio button input.
     */
    name?: string;
    /**
     * Optional radio button value
     */
    value?: string;
    /**
     * Optional Boolean value to disable radio button
     */
    disabled?: boolean;
    /**
     * Optional on change handler
     */
    className?: string;
    /**
   * Optional className for custom styling.
   */
    onChange?: (event: React__default.ChangeEvent<HTMLInputElement>) => void;
    /**
     * Optional Variant of radio button
     */
    variant?: 'primary' | 'info' | 'danger' | 'success' | 'warning';
    /**
     * Optional checked attribute to prefill
     */
    checked?: boolean;
}
declare const RadioButton: React__default.FC<RadioButtonProps>;

interface Option {
    id: number;
    label: string;
}
interface AutocompleteProps {
    /**
     * Label props for Autocomplete
     */
    labelProps?: LabelProps;
    /**
     * Set true or false to display the Label
     */
    showLabel?: boolean;
    /**
     * set boolean value to ensure if error
     */
    error?: boolean;
    /**
     * set boolean value to display/disabled
     */
    disabled?: boolean;
    /**
     * set boolean value to display the border
     */
    showBorder?: boolean;
    /**
     * Customize the border based on boolean
     */
    showBorderOnHover?: boolean;
    /**
     * for customize the Autocomplete use className props(if required)
     */
    className?: string;
    /**
     * for error message passed argument as string
     */
    errorMsg?: string;
    /**
     * Required options for autocomplete in the appropriate manner
     */
    options: Option[];
    /**
     * placeholder for the Autocomplete
     */
    placeholder: string;
    /**
     * for controlled component pass the onChange props
     */
    onChange?: (option: Option) => void;
    /**
     * for clear the selected option from the input onClear is must
     */
    onClear?: () => void;
    /**
     * By Default select one option selectedData is must
     */
    selectedData?: Option;
}
declare const Autocomplete: React__default.FC<AutocompleteProps>;

interface ModalProps {
    isOpen: boolean;
    onClose: () => void;
    /*** label value for aria-label  */
    contentLabel?: string;
    /*** default header will be provided with title and close icon. */
    defaultHeader?: boolean;
    /*** Title to be displayed in the header when defaultHeader is true*/
    headerTitle?: string;
    /*** Optional content to be displayed on the right side of the header when defaultHeader is true */
    headerRightContent?: ReactNode;
    /*** Custom styles for the overlay and content */
    style?: {
        overlay?: React__default.CSSProperties;
        content?: React__default.CSSProperties;
    };
    /*** Custom class names for the modal content */
    contentClassName?: string;
    /*** Custom class name for the overlay */
    overlayClassName?: string;
    /*** Whether the modal should close when the 'Escape' key is pressed */
    shouldCloseOnEsc?: boolean;
    /*** Whether to hide the app from screen readers when the modal is open */
    ariaHideApp?: boolean;
    /*** Whether the modal should close when clicking outside of it (on the overlay) */
    shouldCloseOnOverlayClick?: boolean;
    /***Content to be displayed inside the modal */
    children: ReactNode;
}
declare const Modal: React__default.FC<ModalProps>;

interface SearchProps {
    /**
     * Placeholder for the input field
     */
    placeholder?: string;
    /**
     * Callback function to be called when the search button is clicked or enter key is pressed
     */
    onSearch: (query: string) => void;
    /**
     * Additional styles for the button
     */
    className?: string;
    /**
     * Pass true for transparentBackground button
     */
    style?: React__default.CSSProperties;
    /**
     * If true, the search input field will be disabled
     */
    disabled?: boolean;
    height: string;
    width: string;
    value: string;
    onChange: (event: React__default.ChangeEvent<HTMLInputElement>) => void;
}
declare const Search: ({ placeholder, onSearch, className, style, disabled, height, width, value, onChange, }: SearchProps) => react_jsx_runtime.JSX.Element;

interface RadioOption {
    /**
     * The label to display next to the radio button.
     */
    label: string;
    /**
     * The value associated with this radio button.
     */
    value: string;
    /**
     * Optional Boolean value to disable the radio button.
     */
    disabled?: boolean;
    /**
     * Optional variant for the radio button.
     */
    variant?: RadioButtonProps['variant'];
}
interface RadioGroupProps {
    /**
     * The name associated with all radio buttons in the group.
     */
    name: string;
    /**
     * The array of options to render as radio buttons.
     */
    options: RadioOption[];
    /**
     * The currently selected value.
     */
    selectedValue?: string;
    /**
     * Handler to call when the selected value changes.
     */
    onChange?: (value: string) => void;
    /**
     * Optional variant for all radio buttons in the group.
     */
    variant?: RadioButtonProps['variant'];
    /**
     * Optional className to pass to each radio button for styling.
     */
    className: string;
}
declare const RadioGroup: React__default.FC<RadioGroupProps>;

interface Tab {
    /**
     * Unique identifier for the tab
     */
    id: string;
    /**
     * Label for the tab
     */
    label: string;
    /**
     * Optional icon name for the tab
     */
    iconName?: string;
    /**
     * Icon/Text display option for the tab
     */
    iconText?: 'icon' | 'text' | 'both';
    /**
     * The component/content rendered for the tab
     */
    component: React__default.ReactNode;
    /**
     * Optional flag to disable the tab
     */
    disabled?: boolean;
    /**
     * Optional submenu component
     */
    submenu?: React__default.ReactNode;
}
interface TabsProps {
    /**
     * Array of Tab objects to be rendered in the tab bar
     */
    tabs: Tab[];
}
declare const Tabs: React__default.FC<TabsProps>;

interface NoDataProps {
    /**
     * The content that to be displayed if no data not found
     */
    content: string | ReactNode;
    /**
     * Image that to be displayed if you don't have data
     */
    image?: string;
    /**
     * Size of the image that to be displayed if you don't have data
     */
    size?: 'x-large' | 'large' | 'medium' | 'small' | 'x-small';
}
declare const NoData: ({ content, image, size }: NoDataProps) => react_jsx_runtime.JSX.Element;

interface ListProps {
    /**
     * Data for List
     */
    listItems: Array<ListItemProps>;
    /**
     * Icon position if added
     */
    iconPosition?: 'left' | 'right';
    /**
     * If list item is string then use this props to give its max length
     */
    textMaxWidth?: string;
    /**
     * List onClick function
     */
    onListItemClick: (data: any) => any;
    /**
     * The content that to be displayed if no data not found
     */
    noDataContent: string | ReactNode;
    /**
     * Image that to be displayed if you don't have data
     */
    noDataImage?: string;
    /**
     * Size of the image that to be displayed if you don't have data
     */
    noDataImageSize?: 'x-large' | 'large' | 'medium' | 'small' | 'x-small';
}
interface ListItemProps {
    /**
     * list item  text
     */
    text: string | ReactNode;
    /**
     * Icon if needed to add in the list
     */
    iconName?: string;
    /**
     * To disable list item set it to true
     */
    disable?: boolean;
}
declare const List: ({ listItems, iconPosition, textMaxWidth, onListItemClick, noDataContent, noDataImage, noDataImageSize, }: ListProps) => react_jsx_runtime.JSX.Element;

interface MobileSkinProps {
    children: React.ReactNode | string;
    orientation?: 'portrait' | 'landscape';
    mobileHeight?: number;
    mobileWidth?: number;
}

declare const MobileSkin: React__default.FC<MobileSkinProps>;

type valueType = any;
declare const checkEmpty: (value: valueType) => boolean;

export { Accordion, Autocomplete, Button, Card, Chart, Checkbox, Chip, Drawer, HistoryCard, Icon, IconCard, Input, Label, LabelCard, List, Loader, MenuOption, MobileSkin, Modal, NoData, Popup, RadioButton, RadioGroup, Search, Select, Table, TableTree, TableWithAccordion, Tabs, TextArea, Toaster as Toast, Toggle, Tooltip, checkEmpty };