/// <reference types="react" />
import React$1, { ReactNode, FC } from 'react';

declare type colors = 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'info' | 'dark' | 'light' | 'gradient-primary' | 'white' | string;

declare type placements = 'auto' | 'top' | 'bottom' | 'right' | 'left' | undefined;

declare type size = 'small' | 'medium' | 'large';

interface RdsButtonProps {
    submit?: boolean;
    count?: number;
    isFabIcon?: false;
    isRounded?: false;
    id?: string;
    buttonId?: string;
    isLoading?: boolean;
    showLoadingSpinner?: boolean;
    children?: ReactNode;
    isDisabled?: boolean;
    colorVariant?: colors;
    label?: string;
    block?: boolean;
    size?: string;
    roundedButton?: boolean;
    roundedCorner?: boolean;
    icon?: string;
    isOutline?: boolean;
    tooltip?: boolean;
    tooltipPlacement?: placements;
    tooltipTitle?: string;
    type: "button" | "submit";
    onClick?: React.MouseEventHandler<HTMLButtonElement>;
    formName?: string;
    iconHeight?: string;
    iconWidth?: string;
    iconFill?: boolean;
    iconStroke?: boolean;
    class?: string;
    arialabel?: string;
    databsdismiss?: string;
    databstarget?: string;
    databstoggle?: string;
    ariacontrols?: string;
    iconColorVariant?: string;
    style?: any;
}

declare const RdsButton: FC<RdsButtonProps>;

interface RdsButtonGroupProps {
    vertical: boolean;
    isOutline: boolean;
    colorVariant?: colors;
    size: string;
    role: "checkbox" | "radio" | "button";
    buttonGroupItems: any[];
}
declare const RdsButtonGroup: (props: RdsButtonGroupProps) => JSX.Element;

interface RdsInputProps {
    size?: "small" | "large" | "medium" | string;
    isDisabled?: boolean;
    readonly?: boolean;
    value?: any;
    inputType?: string;
    placeholder?: string;
    labelPositon?: string;
    tooltipPlacement?: placements;
    tooltipTitle?: string;
    name?: string;
    label?: string | "";
    id?: string;
    required?: boolean;
    onChange?: (event: React$1.ChangeEvent<HTMLInputElement>) => any;
    onFocus?: (event: React$1.FocusEvent<HTMLInputElement>) => any;
    onBlur?: (event: React$1.FocusEvent<HTMLInputElement>) => any;
    onClick?: (event: React$1.MouseEvent<HTMLInputElement>) => void;
    onKeyDown?: React$1.KeyboardEventHandler<HTMLInputElement>;
    customClasses?: string;
    formName?: string;
}
declare const RdsInput: React$1.ForwardRefExoticComponent<RdsInputProps & React$1.RefAttributes<unknown>>;

interface RdsCheckboxProps {
    label: string;
    labelClass?: string;
    checked: any;
    isDisabled?: boolean;
    classes?: string;
    isSwitch?: boolean;
    withlabel?: boolean;
    name?: string;
    onChange?: (event: React$1.ChangeEvent<HTMLInputElement>) => any;
    state?: "Checkbox" | "Indeterminate" | "ErrorCheckbox";
    errorMessage?: string;
    id?: string;
}
declare const RdsCheckbox: (props: RdsCheckboxProps) => JSX.Element;

interface RdsCheckboxGroupProps {
    isSwitch?: boolean;
    isInline?: boolean;
    itemList: any;
    label?: string;
    id?: number;
    state?: "Checkbox" | "Indeterminate" | "ErrorCheckbox";
    errorMessage?: string;
    onClick?: React$1.MouseEventHandler<HTMLInputElement>;
}
declare const RdsCheckboxGroup: (props: RdsCheckboxGroupProps) => JSX.Element;

interface RdsCheckboxParentChildProps {
    userData: any[];
}
declare const RdsCheckboxParentChild: (props: RdsCheckboxParentChildProps) => JSX.Element;

interface RdsAvatarProps {
    profilePic?: string;
    withProfilePic?: boolean;
    firstName?: string;
    lastName?: string;
    role?: string;
    colorVariant?: colors;
    titleAlign?: string;
    size?: "small" | "large" | "medium";
    verticallyAlligned?: boolean;
    roundedAvatar?: boolean;
    roundedPills?: boolean;
    height?: string;
    isTitle?: boolean;
}
declare const RdsAvatar: (props: RdsAvatarProps) => JSX.Element;

interface RdsLabelProps {
    children?: ReactNode;
    label?: string;
    multiline?: boolean;
    size?: string;
    class?: string;
    fontWeight?: number | string;
    color?: string;
    required?: boolean;
}
declare const RdsLabel: (props: RdsLabelProps) => JSX.Element;

interface RdsColorPickerProps {
    value: string;
    isDisabled?: boolean;
    label: string;
}
declare const RdsColorPicker: (props: RdsColorPickerProps) => JSX.Element;

interface RdsAddressDetailProps {
    children: ReactNode;
    withIcon?: boolean;
    header?: string;
    addressLine1?: string;
    addressLine2: string;
    addressLine3?: string;
    cardborder?: boolean;
}
declare const RdsAddressDetail: (props: RdsAddressDetailProps) => JSX.Element;

interface breadcrumbprop {
    breadItems: any[];
    role?: string;
}
declare const RdsBreadcrumb: (props: breadcrumbprop) => JSX.Element;

interface RdsSelectProps {
    label: string;
    isDisabled?: boolean;
    isMultiple?: boolean;
    selectedOption?: any;
    size?: string;
    selectItems: any[];
    id?: string;
    selectedValue?: any;
    classes?: string;
    children?: React$1.ReactNode;
    onSelectListChange?: (Event: React$1.ChangeEvent<HTMLSelectElement>) => void;
}
declare const RdsSelectList: (props: RdsSelectProps) => JSX.Element;

interface RdsDropdownProps {
    colorVariant: string;
    size: string;
    darkDropdown: boolean;
    label: string;
    direction: string;
    role: string;
    listItems: any[];
    split: boolean;
    id: string;
    button: ReactNode;
}
declare const RdsDropdown: (props: RdsDropdownProps) => JSX.Element;

interface RdsDatepickerProps {
    DatePickerLabel?: string;
    onDatePicker: (start: any, end: any) => void;
    type?: "default" | "advanced";
}
declare const RdsDatepicker: (props: RdsDatepickerProps) => JSX.Element;

interface RdsCounterProps {
    counterValue: number;
    label?: string;
    min: number;
    max: number;
    width: number;
    colorVariant?: colors;
    position?: placements;
}
declare const RdsCounter: (props: RdsCounterProps) => JSX.Element;

interface RdsCardProps {
    buttonLabel?: string;
    colorVariant?: colors;
    cardTitle?: string;
    cardText?: string;
    showFooter?: boolean;
    isImage?: boolean;
    imageUrl?: string;
    avatarUrl?: string;
    centerAlign?: boolean;
    isAvatar?: boolean;
    borderColor?: colors;
}
declare const RdsCard: (props: RdsCardProps) => JSX.Element;

interface RdsRangeProps {
    max: number;
    min: number;
    step?: number;
    colorVariant?: colors;
    rangeType: string;
}
declare const RdsRange: (props: RdsRangeProps) => JSX.Element;

interface RdsDoubleRangeProps {
    min: number;
    max: number;
    doubleRangeType: "default" | "type_1" | "type_2";
}
declare const RdsDoubleRange: (props: RdsDoubleRangeProps) => JSX.Element;

interface RdsInputGroupProps {
    buttonLabel: string;
    buttonColorVariant: colors;
    placeholder?: string;
    size?: "small" | "medium" | "large";
    inputGroupLabel?: string;
    outline?: boolean;
    inputValue(arg: string): any;
}
declare const RdsInputGroup: (props: RdsInputGroupProps) => JSX.Element;

interface RdsCarouselProps {
    role?: string;
    Indicators: boolean;
    crossFade?: boolean;
    controls?: boolean;
    carouselItems: any[];
}
declare const RdsCarousel: (props: RdsCarouselProps) => JSX.Element;

interface RdsSideNavProps {
    sideNavItems: any[];
    onClick?: (event: React$1.MouseEvent<HTMLAnchorElement>) => void;
    toggleTheme?: React$1.MouseEventHandler<HTMLInputElement>;
}
declare const RdsSideNav: (props: RdsSideNavProps) => JSX.Element;

interface RdsAccordionProps {
    accordionType: string;
    children?: ReactNode;
    accordionId?: string;
    onclick?: (event: React$1.MouseEvent<HTMLInputElement>) => void;
}
declare const RdsAccordion: (props: RdsAccordionProps) => JSX.Element;

interface RdsAlertProps {
    dismisable?: boolean;
    alertmessage: string;
    colorVariant: colors;
    delay?: number;
    icon?: string;
    iconFill?: boolean;
    iconStroke?: boolean;
    iconHeight?: string;
    iconWidth?: string;
    position?: "top" | "bottom";
    style?: any;
}
declare const RdsAlert: (props: RdsAlertProps) => JSX.Element;

interface RdsBadgeProps {
    label: string;
    children?: ReactNode;
    size?: "small" | "smaller" | "smallest" | "medium" | "large" | "xlg";
    colorVariant?: "primary" | "success" | "warning" | "danger" | "info" | "dark" | "light" | "secondary";
    badgeType?: "rectangle" | "circle" | "pill";
    childrenSide?: "right" | "left";
    positioned?: boolean;
    showClose?: boolean;
    onClose?: (Event: React$1.MouseEvent<HTMLSpanElement>) => void;
}
declare const RdsBadge: (props: RdsBadgeProps) => JSX.Element;

interface RdsBannerProps {
    bannerText?: string;
    sticky?: boolean;
    position?: "top" | "bottom";
    colorVariant?: "primary" | "secondary" | "success" | "danger" | "warning" | "info" | "light" | "dark";
    icon?: string;
    closeButton?: boolean;
    textAlign: 'start' | 'end' | 'center';
    iconHeight: string;
    iconWidth: string;
    iconStroke: boolean;
    iconFill: boolean;
}
declare const RdsBanner: (props: RdsBannerProps) => JSX.Element;

interface RdsIconProps {
    width?: string;
    height?: string;
    colorVariant?: string;
    name?: string;
    fill?: boolean;
    stroke?: boolean;
    strokeWidth?: string;
    borderRadius?: string;
    onClick?: React$1.MouseEventHandler<HTMLElement>;
    opacity?: string;
    isAnimate?: boolean;
    classes?: any;
}
declare const RdsIcon: (props: RdsIconProps) => JSX.Element;

declare const Icons: any;

interface RdsIconLabelProps {
    label?: string;
    icon: string;
    size: string;
    iconSize: string;
}
declare const RdsIconLabel: (props: RdsIconLabelProps) => JSX.Element;

interface RdsSearchProps {
    placeholder: string;
    size: string;
    iconside?: "left" | "right";
    value?: string;
    onChange?: (event: React$1.ChangeEvent<HTMLInputElement>) => void;
    onKeyPress?: (event: React$1.KeyboardEvent) => void;
}
declare const RdsSearch: (props: RdsSearchProps) => JSX.Element;

interface RdsNavbarProps {
    size?: string;
    navbarItems: any[];
    title?: string;
}
declare const RdsNavbar: (props: RdsNavbarProps) => JSX.Element;

interface RdsDropdownListProps {
    id?: string;
    reset?: boolean;
    icon?: string;
    iconFill?: boolean;
    iconWidth?: string;
    iconStroke?: boolean;
    iconHeight?: string;
    placeholder?: string;
    borderDropdown?: boolean;
    listItems: {
        label: string;
        val: string;
        icon?: string;
        iconWidth?: string;
        iconHeight?: string;
    }[];
    multiSelect?: boolean;
    xOffset?: string;
    yOffset?: string;
    onClick?: (event: React$1.MouseEvent<HTMLAnchorElement>) => void;
    selectedItems?: (selectedItems: any) => void;
    selectedIndex?: (selectedindex: number) => void;
}
declare const RdsDropdownList: (props: RdsDropdownListProps) => JSX.Element;

interface RdsFabMenuProps {
    colorVariant?: colors;
    size?: string;
    menuIcon?: string;
    menuiconWidth?: string;
    menuiconHeight?: string;
    listItems: any[];
    onClick?: (React$1.MouseEventHandler<HTMLButtonElement>);
}
declare const RdsFabMenu: (props: RdsFabMenuProps) => JSX.Element;

interface RdsWidgetProps {
    isRefreshRequired?: boolean;
    colorVariant?: colors;
    headerTitle: string;
    children?: ReactNode;
    class?: string;
    style?: any;
    subTitleColorVariant?: string;
    height?: string;
    width?: string;
    bigNumber?: string;
    subTitle?: string;
    minHeight?: string;
    icon?: string;
    iconHeight?: string;
    iconStroke?: boolean;
    iconFill?: boolean;
    iconWidth?: string;
    iconColor?: string;
    border?: boolean;
    bigNumberColor?: string;
    onRefresh?: React$1.MouseEventHandler<HTMLDivElement>;
}
declare const RdsWidget: (props: RdsWidgetProps) => JSX.Element;

interface RdsIllustrationProps {
    label?: string;
    subLabel?: string;
    colorVariant?: colors;
}
declare const RdsIllustration: (props: RdsIllustrationProps) => JSX.Element;

interface RdsBigNumberProps {
    colorVariant?: string;
    subTitleColorVariant?: string;
    bigNumber: string;
    bigNumberColor?: string;
    subTitle?: string;
    class?: string;
    icon?: string;
    iconHeight?: string;
    iconStroke?: boolean;
    iconFill?: boolean;
    iconWidth?: string;
    iconColor?: string;
    children?: ReactNode;
    textAlign?: 'text-start' | 'text-center' | 'text-end';
}
declare const RdsBigNumber: (props: RdsBigNumberProps) => JSX.Element;

interface RdsSpinnerProps {
    spinnerType?: string;
    colorVariant?: string;
    width?: string;
    borderWidth?: string;
    height?: string;
}
declare const RdsSpinner: (props: RdsSpinnerProps) => JSX.Element;

interface RdsLikeDislikeProps {
    colorVariant?: string;
    like: number;
    dislike: number;
    onClick?: (like: number, dislike: number) => void;
}
declare const RdsLikeDislike: (props: RdsLikeDislikeProps) => JSX.Element;

interface RdsTextAreaProps {
    rows?: number;
    readonly?: boolean;
    label?: string;
    placeholder: string;
    value?: any;
    isDisabled?: boolean;
    isRequired?: boolean;
    id?: string;
    required?: boolean;
    onChange?: (event: React$1.ChangeEvent<HTMLTextAreaElement>) => void;
    labelPosition?: string;
    onClick?: (event: React$1.MouseEvent<HTMLTextAreaElement>) => void;
}
declare const RdsTextArea: (props: RdsTextAreaProps) => JSX.Element;

interface RdsBenefitProps {
    item: any;
    displayType: string;
}
declare const RdsBenefit: (props: RdsBenefitProps) => JSX.Element;

interface RdsBankCardDetailProps {
    cardDatas: any;
    isSelectable?: boolean;
    isEditable?: boolean;
}
declare const RdsBankCardDetail: (props: RdsBankCardDetailProps) => JSX.Element;

interface RdsStatProps {
    displayType: 'basic' | 'advanced';
    items: any[];
    colorVariant?: string;
    backgroundColorVarient?: string;
    textColor?: string;
}
declare const RdsStat: (props: RdsStatProps) => JSX.Element;

interface RdsNotificationProps {
    colorVariant?: colors;
    notifications: any[];
    footerText: string;
    onSetAsRead?: (Event: React$1.MouseEventHandler<HTMLButtonElement>, notification: any) => void;
    onMarkAsRead?: (Event: React$1.MouseEventHandler<HTMLButtonElement>, notifications: any) => void;
}
declare const RdsNotification: (props: RdsNotificationProps) => JSX.Element;

interface RdsToastProps {
    colorVariant?: colors;
    headerTitle: string;
    message: string;
    delay: number;
    autohide: boolean;
    borderColor: string;
    showHeader: boolean;
}
declare const RdsToast: (props: RdsToastProps) => JSX.Element;

interface RdsSizeProps {
    sizeType: string;
    sizeData: any[];
    sizeDataWithDescription: any[];
}
declare const RdsSize: (props: RdsSizeProps) => JSX.Element;

interface RdsRadioButtonProps {
    switch?: boolean;
    inline?: boolean;
    isInputGroup?: boolean;
    onClick?: React$1.MouseEventHandler<HTMLInputElement>;
    itemList: any;
    displayType?: string;
    label?: string;
    id?: number;
    state?: 'radio' | 'errorRadio';
    errorMessage?: string;
}
declare const RdsRadioButton: (props: RdsRadioButtonProps) => JSX.Element;

interface RdsAppDetailProps {
    appDetailsItem: any;
}
declare const RdsAppDetail: (props: RdsAppDetailProps) => JSX.Element;

interface RdsOffcanvasProps {
    placement: "start" | "end" | "top" | "bottom";
    backDrop: "static" | true | false;
    scrolling: boolean;
    preventEscapeKey: boolean;
    offId: any;
    canvasTitle: string;
    offcanvaswidth: number;
    onShow?: React$1.EventHandler<HTMLAllCollection | any>;
    onClose?: React$1.EventHandler<HTMLAllCollection | any>;
    buttonname?: string;
    offcanvasbutton?: ReactNode;
    children?: ReactNode;
    onclick?: (data: any) => void;
    className?: string;
}
declare const RdsOffcanvas: (props: RdsOffcanvasProps) => JSX.Element;

interface RdsTableProps {
    headerDatas: any[];
    tableDatas: any[];
    colorVariant?: string;
    id?: string;
    striped?: boolean;
    bordered?: boolean;
    iconColorVariant?: string;
    width?: number;
    backgroundColor?: string;
    headerTextColor?: string;
    tableHeightForScroll?: string;
}
declare const RdsTable: (props: RdsTableProps) => JSX.Element;

interface RdsModalProps {
    modalId: string;
    modalBackdrop?: boolean | "static";
    preventEscapeKey?: boolean;
    size?: "small" | "large" | "extra-large" | "fullscreen" | "default";
    modalAnimation?: "modal fade" | "modal fade-scale" | "modal fade-rotate" | "modal fade-flip";
    showModalFooter?: boolean;
    showModalHeader?: boolean;
    modalData?: any;
    scrollable?: boolean;
    verticallyCentered?: boolean;
    modalbutton?: any;
    children: any;
    modalTitle?: string;
    saveChangesName?: string;
    cancelButtonName?: string;
}
declare const RdsModal: (props: RdsModalProps) => JSX.Element;

interface RdsNavtabsProps {
    children?: ReactNode;
    navtabsItems: {
        label: string;
        tablink?: string;
        ariacontrols?: string;
        icon?: string;
        subText?: string;
        disabled?: boolean;
        id: any;
    }[];
    type: "default" | "pills" | "tabs" | "vertical";
    fill?: boolean;
    justified?: boolean;
    activeNavtabOrder?: (id: any) => void;
    activeNavTabId?: any;
    isNextPressed?: boolean;
    onClick?: React$1.MouseEvent<HTMLElement>;
}
declare const RdsNavtabs: (props: RdsNavtabsProps) => JSX.Element;

interface RdsRatingProps {
    rating: number;
    reviewPosition?: "left" | "right" | "none";
    colorVariant?: colors;
    noOfReviews?: number;
    size?: size;
    seeAllOption?: boolean;
    onSeeAll?: () => void;
}
declare const RdsRating: (props: RdsRatingProps) => JSX.Element;

interface RdsPopularPageProps {
    itemList: any;
}
declare const RdsPopularPage: (props: RdsPopularPageProps) => JSX.Element;

interface RdsColorSwitcherProps {
    header?: string;
    itemList: {
        id: number;
        color: string;
    }[];
    defaultValue?: number;
    displayType?: "rounded" | "square";
    selectedColor?: (event: React$1.MouseEvent<HTMLDivElement>, selected_Color: any) => void;
}
declare const RdsColorSwitcher: (props: RdsColorSwitcherProps) => JSX.Element;

interface RdsListGroupProps {
    labelPosition?: string;
    label?: string;
    listItem: any[];
    listGroupWithMultiSelect?: boolean;
    withBadge?: boolean;
}
declare const RdsListGroup: (props: RdsListGroupProps) => JSX.Element;

interface RdsProductImageProps {
    displayType: string | "basic" | "product-overview1" | "product-overview2" | "product-overview3";
    images: string[];
    itemList: string[];
}
declare const RdsProductImage: (props: RdsProductImageProps) => JSX.Element;

interface RdsPaginationProps {
    totalRecords: number;
    recordsPerPage?: any;
    paginationType?: string;
    alignmentType?: string;
    size?: string;
    onPageChange?: (currentPage: number, recordsPerPage: number) => void;
}
declare const RdsPagination: (props: RdsPaginationProps) => JSX.Element;

interface RdsCollapseProps {
    children: ReactNode;
    buttonList: any[];
    horizontalCollapse: boolean;
    multitoggle: boolean;
}
declare const RdsCollapse: (props: RdsCollapseProps) => JSX.Element;

interface RdsFeatureListProps {
    heading: string;
    itemList: string[];
    columns: number;
    fontStyle?: "italic" | "normal";
    colorVariant?: 'primary' | 'success' | 'danger' | 'warning' | 'light' | 'info' | 'secondary' | 'dark';
}
declare const RdsFeatureList: (props: RdsFeatureListProps) => JSX.Element;

interface RdsPopoverProps {
    children: ReactNode;
    popoverPosition: string;
}
declare const RdsPopover: (props: RdsPopoverProps) => JSX.Element;

interface RdsPriceProps {
    mrp: number;
    currentPrice: number;
    type?: "priceOnLeft" | "priceOnRight";
    withDiscount: boolean;
}
declare const RdsPrice: (props: RdsPriceProps) => JSX.Element;

interface RdsProgressBarProps {
    colorVariant: string;
    striped?: string;
    progressWidth: number;
    animation?: boolean;
    height?: number;
    progressValues?: any[];
    role: string;
    displayLevel?: boolean;
    displaypercentage?: boolean;
    width?: string;
}
declare const RdsProgressBar: (props: RdsProgressBarProps) => JSX.Element;

interface Item {
    name: string;
    date?: Date;
    imageUrl?: string;
    rating?: 0 | 1 | 2 | 3 | 4 | 5;
    reviewTitle?: string;
    reviewSubTitle?: string;
    description?: string;
    likes?: number;
    dislikes?: number;
}
interface RdsReviewCategoryProps {
    display_type: string;
    item: Item;
}
declare const RdsReviewCategory: (props: RdsReviewCategoryProps) => JSX.Element;

interface RdsScrollspyProps {
}
declare const RdsScrollspy: (props: RdsScrollspyProps) => JSX.Element;

interface RdsTeamMemberProps {
    displayType: string;
    teamItem: any[];
}
declare const RdsTeamMember: (props: RdsTeamMemberProps) => JSX.Element;

interface RdsTestimmonialProps {
    testimonialItems: any[];
}
declare const RdsTestimonial: (props: RdsTestimmonialProps) => JSX.Element;

declare const Tooltip: (p: {
    children: JSX.Element;
    text?: string;
    place?: placements;
}) => React$1.FunctionComponentElement<any>;

interface RdsWebsiteMatrixProps {
    colorVariant?: colors;
    item: any;
    onClickLink: (event: React$1.MouseEvent<HTMLAnchorElement>, clicked: boolean) => void;
    displayType?: string;
}
declare const RdsWebsiteMatrix: (props: RdsWebsiteMatrixProps) => JSX.Element;

interface RdsTextEditorProps {
    bounds?: string | HTMLElement;
    children?: React$1.ReactElement<any>;
    className?: string;
    defaultValue?: any;
    formats?: string[];
    id?: string;
    modules?: any;
    onChange?(value: string, delta: any, source: any, editor: any): any;
    placeholder?: string;
    preserveWhitespace?: boolean;
    readOnly?: boolean;
    style?: React$1.CSSProperties;
    tabIndex?: number;
    theme?: string;
    value?: string;
    label?: string;
    required?: boolean;
    labelClass?: string;
}
declare const RdsTextEditor: (props: RdsTextEditorProps) => JSX.Element;

interface RdsFileUploaderProps {
    placeholder?: string;
    size: string;
    colorVariant?: string;
    multiple?: boolean;
    extensions: string;
    limit: number;
    label: string;
    onFileArray?: (files: any[]) => void;
}
declare const RdsFileUploader: (props: RdsFileUploaderProps) => JSX.Element;

interface RdsToggleProps {
    onClick?: React$1.MouseEventHandler<HTMLInputElement>;
    iconOnUncheck: string;
    iconOnCheck: string;
    small?: boolean;
}
declare const RdsToggle: (props: RdsToggleProps) => JSX.Element;

interface lineprops {
    labels: any[];
    options: any;
    dataSets: any[];
    height?: number;
    width?: number;
    id: string;
    isGradient: boolean;
}
declare const RdsAreaChart: (props: lineprops) => JSX.Element;

interface Rdslineprops {
    labels: any[];
    options: any;
    dataSets: any[];
    height: number;
    width: number;
    id: string;
}
declare const RdsLineChart: (props: Rdslineprops) => JSX.Element;

interface RdsPieprops {
    labels: any[];
    options: any;
    dataSets: any[];
    height?: number;
    width?: number;
    id: string;
}
declare const RdsPieChart: (props: RdsPieprops) => JSX.Element;

interface RdsDoughnutprops {
    labels: any[];
    options: any;
    dataSets: any[];
    id: string;
    height?: number;
    width?: number;
    titleText?: string;
    subTitleText?: string;
}
declare const RdsDoughnutChart: (props: RdsDoughnutprops) => JSX.Element;

interface RdsBarChartProps {
    labels: any[];
    options: any;
    dataSets: any[];
    width: number;
    height: number;
    id: string;
}
declare const RdsBarChart: (props: RdsBarChartProps) => JSX.Element;

interface RdsBooleanChartProps {
    labels: any[];
    options: any;
    dataSets: any[];
    width?: number;
    chartStyle?: string;
    id: string;
    height?: number;
    centerIconName?: string;
}
declare const RdsBooleanChart: (props: RdsBooleanChartProps) => JSX.Element;

interface RdsMixedChartProps {
    labels: any[];
    options: any;
    dataSets: any[];
    width?: number;
    height?: number;
    chartStyle: string;
    id: string;
}
declare const RdsMixedChart: (props: RdsMixedChartProps) => JSX.Element;

interface RdsPolarAreaChartProps {
    labels: any[];
    options: any;
    dataSets: any[];
    width?: number;
    height?: number;
    chartStyle: string;
    id: string;
}
declare const RdsPolarAreaChart: (props: RdsPolarAreaChartProps) => JSX.Element;

interface RdsRadarprops {
    labels: any[];
    options: any;
    dataSets: any[];
    height?: number;
    width?: number;
    id: string;
}
declare const RdsRadarChart: (props: RdsRadarprops) => JSX.Element;

interface RdsScatterChartProps {
    labels: any[];
    options: any;
    dataSets: any[];
    width: number;
    height?: number;
    chartStyle: string;
    id: string;
}
declare const RdsScatterChart: (props: RdsScatterChartProps) => JSX.Element;

interface RdsStackedprops {
    labels: any[];
    options: any;
    dataSets: any[];
    height?: number;
    width?: number;
    id: string;
}
declare const RdsStackedChart: (props: RdsStackedprops) => JSX.Element;

interface RdsBubbleChartProps {
    chartLabels: any[];
    chartOptions: any;
    chartDataSets: any[];
    chartdata: any[];
    chartWidth: number;
    chartStyle: string;
}
declare const RdsBubbleChart: (props: RdsBubbleChartProps) => JSX.Element;

export { Icons, RdsAccordion, RdsAddressDetail, RdsAlert, RdsAppDetail, RdsAreaChart, RdsAvatar, RdsBadge, RdsBankCardDetail, RdsBanner, RdsBarChart, RdsBenefit, RdsBigNumber, RdsBooleanChart, RdsBreadcrumb, RdsBubbleChart, RdsButton, RdsButtonGroup, RdsCard, RdsCarousel, RdsCheckbox, RdsCheckboxGroup, RdsCheckboxParentChild, RdsCollapse, RdsColorPicker, RdsColorSwitcher, RdsCounter, RdsDatepicker as RdsDatePicker, RdsDoubleRange, RdsDoughnutChart, RdsDropdown as RdsDowndrop, RdsDropdownList, RdsFabMenu, RdsFeatureList, RdsFileUploader, RdsIcon, RdsIconLabel, RdsIllustration, RdsInput, RdsInputGroup, RdsLabel, RdsLikeDislike, RdsLineChart, RdsListGroup, RdsMixedChart, RdsModal, RdsNavbar, RdsNavtabs, RdsNotification, RdsOffcanvas, RdsPagination, RdsPieChart, RdsPolarAreaChart, RdsPopover, RdsPopularPage, RdsPrice, RdsProductImage, RdsProgressBar, RdsRadarChart, RdsRadioButton, RdsRange, RdsRating, RdsReviewCategory, RdsScatterChart, RdsScrollspy, RdsSearch, RdsSelectList, RdsSideNav, RdsSize, RdsSpinner, RdsStackedChart, RdsStat, RdsTable, RdsTeamMember, RdsTestimonial, RdsTextArea, RdsTextEditor, RdsToast, RdsToggle, Tooltip as RdsTooltip, RdsWebsiteMatrix, RdsWidget };
