grepsr-ui-elements/dist/index.d.ts

/// <reference types="react" />
import { AlertProps as AlertProps$1, TypographyProps, BadgeProps, TextFieldProps as TextFieldProps$2, SvgIconProps, SelectChangeEvent } from '@mui/material';
import PropTypes from 'prop-types';
import * as React from 'react';
import React__default, { ReactNode, MouseEventHandler, ReactElement, ElementType, JSXElementConstructor, ChangeEventHandler, KeyboardEventHandler, ReactEventHandler, SyntheticEvent, ComponentType } from 'react';
import { AvatarProps } from '@mui/material/Avatar';
import { DateRange } from '@mui/x-date-pickers-pro/DateRangePicker';
import { TransitionProps } from '@mui/material/transitions';
import { ReactJSXElement } from '@emotion/react/types/jsx-namespace';
import Fade from '@mui/material/Fade';
import { TooltipProps } from '@mui/material/Tooltip';
import { TypographyProps as TypographyProps$1 } from '@mui/material/Typography';

interface ExtendAlertProps extends AlertProps$1 {
    backgroundColor?: string;
    padding?: any;
    onClose?: () => void | undefined;
}

declare const GrepsrAlert: {
    (props: ExtendAlertProps): JSX.Element;
    defaultProps: {
        title: string;
        color: string;
        variant: string;
        severity: string;
        icon: boolean;
        onClose: undefined;
    };
    propTypes: {
        icon: PropTypes.Requireable<PropTypes.ReactNodeLike>;
        title: PropTypes.Validator<any>;
        color: PropTypes.Requireable<string>;
        severity: PropTypes.Requireable<string>;
        variant: PropTypes.Requireable<string>;
    };
};

interface AlertProps {
    /**
     * Alert contents
     */
    title: ReactNode;
    /**
     * Alert color
     */
    color: "info" | "success" | "error" | "warning";
    /**
     * Alert severity. The severity of the alert. This defines the color and icon used.
     */
    severity?: "info" | "success" | "error" | "warning" | string | undefined;
    /**
     * Alert icon
     *
     */
    icon?: ReactNode;
    /**
     * Alert variant
     */
    variant: "filled" | "outlined" | "standard";
    /**
     * Alert action
     */
    action?: ReactNode;
    /**
     * Alert close handler
     */
    onClose?: () => void;
    /**
     * Alert helper text
     */
    helperText?: string;
    /**
     * Alert rest props
     */
    restProps: any;
}

declare const GrepsrAlertHeading: {
    (props: AlertProps): JSX.Element;
    defaultProps: {
        title: string;
        color: string;
        variant: string;
        severity: string;
    };
    propTypes: {
        title: PropTypes.Validator<NonNullable<PropTypes.ReactNodeLike>>;
        color: PropTypes.Validator<string>;
        variant: PropTypes.Validator<string>;
        severity: PropTypes.Requireable<string>;
        onClose: PropTypes.Requireable<(...args: any[]) => any>;
        helperText: PropTypes.Requireable<string>;
        restProps: PropTypes.Requireable<Object>;
    };
};

interface ExtendAvatarProps extends AvatarProps {
    isAvatarLetter?: boolean;
    avatarTitle: ReactNode | string | undefined | any;
    backgroundColor?: string;
    isAvatarTitleShow: boolean;
    avatarTitleVariant: TypographyProps["variant"];
}

declare const GrepsrAvatar: {
    (props: ExtendAvatarProps): JSX.Element;
    defaultProps: {
        alt: string;
        isAvatarLetter: boolean;
        avatarTitle: string;
        variant: string;
        isAvatarTitleShow: boolean;
        avatarTitleVariant: string;
    };
    propTypes: {
        isAvatarLertter: PropTypes.Requireable<boolean>;
        avatarTitle: PropTypes.Validator<string>;
        backgroundColor: PropTypes.Requireable<string>;
        isAvatarTitleShow: PropTypes.Validator<boolean>;
        avatarTitleVariant: PropTypes.Validator<string>;
    };
};

interface AvatarGroupProps {
    max: number;
    isLetterAvatar?: boolean;
    letterAvatarArr?: Array<any> | any;
    imageAvatarArr: Array<any>;
    onClick?: MouseEventHandler<HTMLElement> | undefined;
    onClose?: (() => void) | undefined;
    anchorEl?: Element | ((element: Element) => Element) | null | undefined;
    open?: boolean | undefined;
}

declare const GrepsrAvatarGroup: {
    ({ max, isLetterAvatar, imageAvatarArr, letterAvatarArr, anchorEl, onClose, onClick, open }: AvatarGroupProps): JSX.Element;
    defaultProps: {
        max: number;
        isLetterAvatar: boolean;
        imageAvatarArr: {
            id: number;
            alt: string;
            title: string;
        }[];
        letterAvatarArr: never[];
    };
    propTypes: {
        imageAvatarArr: PropTypes.Validator<any[]>;
        max: PropTypes.Validator<number>;
        isLetterAvatar: PropTypes.Requireable<boolean>;
        letterAvatarArr: PropTypes.Requireable<any[]>;
    };
};

interface ExtendBadgeProps$1 extends BadgeProps {
}

declare const GrepsrBadge: {
    (props: ExtendBadgeProps$1): JSX.Element;
    defaultProps: {
        color: string;
        badgeContent: string;
        className: string;
    };
    propTypes: {
        color: PropTypes.Validator<string>;
        badgeContent: PropTypes.Validator<any>;
        className: PropTypes.Requireable<string>;
    };
};

interface ExtendBadgeProps extends BadgeProps {
}

declare const GrepsrBadgeIcon: {
    (props: ExtendBadgeProps): JSX.Element;
    defaultProps: {
        badgeContent: number;
        color: string;
        invisible: boolean;
        showZero: boolean;
        max: number;
        variant: string;
        overlap: string;
        anchorOrigin: {
            vertical: string;
            horizontal: string;
        };
    };
    propTypes: {
        badgeContent: PropTypes.Validator<any>;
        color: PropTypes.Validator<string>;
        invisible: PropTypes.Requireable<boolean>;
        showZero: PropTypes.Requireable<boolean>;
        max: PropTypes.Requireable<number>;
        overlap: PropTypes.Validator<string>;
        variant: PropTypes.Validator<string>;
        anchorOrigin: PropTypes.Validator<object>;
    };
};

interface BreadcrumbProps {
    className?: string;
    ariaLabel?: string;
    itemsAfterCollapse?: number;
    itemsBeforeCollapse?: number;
    maxItems?: number;
    separator?: ReactNode;
    breadcrumbArr?: Array<any>[] | undefined;
    interactiveBreadcrumb: string;
}

declare const GrepsrBreadcrumbs: {
    (props: BreadcrumbProps): JSX.Element;
    defaultProps: {
        className: string;
        separator: string;
        ariaLabel: string;
        itemsAfterCollapse: number;
        itemsBeforeCollapse: number;
        maxItems: number;
        breadcrumbArr: never[];
        interactiveBreadcrumb: string;
    };
    propTypes: {
        className: PropTypes.Requireable<string>;
        itemsAfterCollapse: PropTypes.Requireable<number>;
        itemsBeforeCollapse: PropTypes.Requireable<number>;
        maxItems: PropTypes.Requireable<number>;
        separator: PropTypes.Requireable<PropTypes.ReactNodeLike>;
        ariaLabel: PropTypes.Requireable<string>;
        breadcrumbArr: PropTypes.Requireable<any[]>;
        interactiveBreadcrumb: PropTypes.Validator<string>;
    };
};

interface ButtonProps {
    /**
     * Button contents
     */
    children?: ReactNode | ReactElement | undefined;
    component?: ElementType<any> | undefined;
    /**
     * Button color
     */
    color: "inherit" | "primary" | "success" | "error" | "info" | "warning" | string;
    /**
     * Button size
     */
    size: "small" | "medium" | "large";
    /**
     * Button variant
     */
    variant: "contained" | "outlined" | "text";
    /**
     * Button disabled
     */
    disabled?: boolean;
    /**
     * Button fullWidth
     */
    fullWidth?: boolean;
    /**
     * Button start icon
     *
     */
    startIcon?: ReactNode;
    /**
     * Button end icon
     *
     */
    endIcon?: ReactNode;
    isIconButton?: boolean | undefined;
    arialabelIconbtn?: string;
    iconButton?: ReactNode | ReactElement;
    iconButtonColor?: string;
    /**
     * Button click handler
     */
    onClick?: MouseEventHandler<HTMLButtonElement> | MouseEventHandler<any> | (() => void) | undefined;
    ariaControls?: string;
    /**
     * Button rest props
     */
    restProps?: any;
    sx?: any | undefined;
}

declare const GrepsrButton: {
    (props: ButtonProps): JSX.Element;
    defaultProps: {
        size: string;
        variant: string;
        color: string;
        fullWidth: boolean;
        isIconButton: boolean;
        iconButton: JSX.Element;
        arialabelIconbtn: string;
        ariaControls: string;
        disabled: boolean;
        startIcon: boolean;
        endIcon: boolean;
        onClick: string;
        sx: {};
    };
    propTypes: {
        children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
        disabled: PropTypes.Requireable<boolean>;
        startIcon: PropTypes.Requireable<boolean>;
        endIcon: PropTypes.Requireable<boolean>;
        fullWidth: PropTypes.Requireable<boolean>;
        color: PropTypes.Validator<string>;
        size: PropTypes.Validator<string>;
        variant: PropTypes.Validator<string>;
        isIconButton: PropTypes.Requireable<boolean>;
        iconButton: PropTypes.Requireable<PropTypes.ReactNodeLike>;
        iconButtonColor: PropTypes.Requireable<string>;
        arialabelIconbtn: PropTypes.Requireable<string>;
        ariaControls: PropTypes.Requireable<string>;
        component: PropTypes.Requireable<PropTypes.ReactComponentLike>;
        onClick: PropTypes.Requireable<(...args: any[]) => any>;
    };
};

interface ButtonGroupProps {
    children?: ReactNode;
    sx?: Array<Function | object | boolean> | Function | object;
    ariaLabel: string;
    color?: "inherit" | "primary" | "secondary" | "success" | "error" | "info" | "warning";
    variant?: "contained" | "outlined" | "text" | "containedOutlined" | "primaryGhost" | string;
    orientation?: "vertical" | "horizontal";
    fullWidth?: boolean | undefined;
    disabled?: boolean;
    disableElevation?: boolean;
    disableRipple?: boolean;
    disableFocusRipple?: boolean;
    restProps?: any;
}

declare const GrepsrButtonGroup: {
    (props: ButtonGroupProps): JSX.Element;
    defaultProps: {
        ariaLabel: string;
        color: string;
        variant: string;
        orientation: string;
        fullWidth: boolean;
        disabled: boolean;
    };
    propTypes: {
        color: PropTypes.Requireable<string>;
        variant: PropTypes.Requireable<string>;
        orientation: PropTypes.Requireable<string>;
        fullWidth: PropTypes.Requireable<boolean>;
        disabled: PropTypes.Requireable<boolean>;
        ariaLabel: PropTypes.Requireable<string>;
    };
};

interface CheckboxProps {
    checked?: boolean;
    checkedIcon?: ReactNode;
    label: string;
    color: 'default' | 'primary' | 'secondary' | 'error' | 'info' | 'success' | 'warning';
    defaultChecked?: boolean;
    disabled?: boolean;
    disableRipple?: boolean;
    icon?: ReactNode;
    indeterminate?: boolean;
    indeterminateIcon?: ReactNode;
    size: 'medium' | 'small';
    required?: boolean;
    onChange?: () => void;
}

declare const GrepsrCheckbox: {
    (props: CheckboxProps): JSX.Element;
    defaultProps: {
        label: string;
        disabled: boolean;
        defaultChecked: boolean;
        color: string;
        indeterminate: boolean;
        disableRipple: boolean;
        size: string;
        required: boolean;
        checked: boolean;
    };
    propTypes: {
        label: PropTypes.Validator<string>;
        disabled: PropTypes.Requireable<boolean>;
        defaultChecked: PropTypes.Requireable<boolean>;
        color: PropTypes.Validator<string>;
        indeterminate: PropTypes.Requireable<boolean>;
        disableRipple: PropTypes.Requireable<boolean>;
        size: PropTypes.Validator<string>;
        required: PropTypes.Requireable<boolean>;
        onchange: PropTypes.Requireable<(...args: any[]) => any>;
        checked: PropTypes.Requireable<boolean>;
    };
};

interface CheckboxGroupsProps {
    columnSpacing: any;
    rowSpacing?: number;
    direction?: string;
    indeterminate?: boolean;
    defaultChecked?: boolean;
    checkboxArray?: any[] | undefined | void;
    disabled?: boolean;
    onChange?: () => void;
}

declare const GrepsrCheckboxGroup: {
    (props: CheckboxGroupsProps): JSX.Element;
    defaultProps: {
        rowSpacing: number;
        colSpacing: number;
        direction: string;
        checkboxArray: never[];
    };
    propTypes: {
        rowSpacing: PropTypes.Requireable<number>;
        columnSpacing: PropTypes.Requireable<number>;
        column: PropTypes.Requireable<string>;
        checkboxArray: PropTypes.Requireable<any[]>;
    };
};

interface ChipsProps {
    label: string;
    variant: "filled" | "outlined";
    size: "medium" | "small";
    color: any;
    isAvatarLetter?: boolean;
    avatar?: any;
    avatarLetter?: string;
    avatarImage?: any;
    avatarImageAlt?: string;
    icon?: ReactElement<any, string | JSXElementConstructor<any>> | undefined;
    isIcon?: any;
    iconValue?: Node;
    disabled?: boolean;
    clickable?: boolean;
    deletable?: boolean;
    onClick?: () => void | undefined;
    onDelete?: () => void | undefined;
    src?: any | undefined;
    sx?: any;
    borderColor?: any;
    textColor?: any;
}

declare const GrepsrChips: {
    (props: ChipsProps): JSX.Element;
    defaultProps: {
        label: string;
        variant: string;
        size: string;
        color: string;
    };
    propTypes: {
        label: PropTypes.Validator<string>;
        variant: PropTypes.Validator<string>;
        size: PropTypes.Validator<string>;
        color: PropTypes.Validator<any>;
    };
};

interface DatePickerProps {
    onChange: (value: unknown, keyboardInputValue?: string | undefined) => void;
    renderInput: (props: TextFieldProps$2) => ReactElement<any, string | JSXElementConstructor<any>>;
    datePickerlabel?: string | undefined;
    disabled?: boolean | undefined;
    dateRangePickerlabel?: string;
    value?: any;
}

declare const GrepsrDatePicker: {
    (props: DatePickerProps): JSX.Element;
    defaultProps: {
        disabled: boolean;
    };
    propTypes: {
        disabled: PropTypes.Requireable<boolean>;
    };
};

interface DateRangePickerProps {
    onChange?: (date: DateRange<any>, keyboardInputValue?: string | undefined) => void;
    dateRangePickerlabelStart?: string | undefined;
    dateRangePickerlabelEnd?: string | undefined;
    disabled?: boolean | undefined;
    value?: DateRange<any>;
}

declare const GrepsrDateRangePicker: {
    (props: DateRangePickerProps): JSX.Element;
    defaultProps: {
        dateRangePickerlabelStart: string;
        dateRangePickerlabelEnd: string;
        disabled: boolean;
    };
    propTypes: {
        dateRangePickerlabelStart: PropTypes.Requireable<string>;
        DateRangePickerlabelEnd: PropTypes.Requireable<string>;
        disabled: PropTypes.Requireable<boolean>;
    };
};

interface TextFieldProps$1 {
    autoFocus?: boolean;
    defaultValue?: any;
    disabled?: boolean;
    error?: boolean;
    fullWidth?: boolean;
    helperText?: string | undefined;
    id: string | undefined;
    InputLabelProps?: {
        shrink: boolean;
    } | object;
    label?: string | undefined;
    multiline?: boolean;
    name: string | undefined;
    onChange?: ChangeEventHandler<HTMLTextAreaElement | HTMLInputElement> | undefined;
    onKeyDown?: KeyboardEventHandler<HTMLDivElement> | undefined;
    onClick?: (() => void) | undefined;
    placeholder?: string;
    required?: boolean;
    select?: boolean;
    size: "medium" | "small";
    type: string | undefined;
    value?: any;
    variant: "filled" | "outlined" | "standard";
    startIcon: any | null;
    endIcon: any | null;
    isIcon: boolean;
}

declare const GrepsrForm: {
    (props: TextFieldProps$1): JSX.Element;
    defaultProps: {
        label: string;
        autoFocus: boolean;
        disabled: boolean;
        fullWidth: boolean;
        helperText: string;
        error: boolean;
        id: string;
        name: string;
        placeholder: string;
        type: string;
        multiline: boolean;
        required: boolean;
        select: boolean;
        size: string;
        variant: string;
    };
    propTypes: {
        id: PropTypes.Validator<string>;
        name: PropTypes.Validator<string>;
        size: PropTypes.Validator<string>;
        type: PropTypes.Validator<string>;
        variant: PropTypes.Validator<string>;
        autoFocus: PropTypes.Requireable<boolean>;
        disabled: PropTypes.Requireable<boolean>;
        error: PropTypes.Requireable<boolean>;
        fullWidth: PropTypes.Requireable<boolean>;
        helperText: PropTypes.Requireable<string>;
        label: PropTypes.Requireable<string>;
        select: PropTypes.Requireable<boolean>;
        placeholder: PropTypes.Requireable<string>;
        required: PropTypes.Requireable<boolean>;
        isIcon: PropTypes.Requireable<boolean>;
        multiline: PropTypes.Requireable<boolean>;
        value: PropTypes.Requireable<any>;
    };
};

interface TextFieldProps {
    autoFocus?: boolean;
    defaultValue?: any;
    disabled?: boolean;
    error?: boolean;
    fullWidth?: boolean;
    helperText?: string | undefined;
    id: string | undefined;
    InputLabelProps?: {
        shrink: boolean;
    } | object;
    label?: string | undefined;
    multiline?: boolean;
    name: string | undefined;
    onChange?: ChangeEventHandler<HTMLTextAreaElement | HTMLInputElement> | undefined;
    onKeyDown?: KeyboardEventHandler<HTMLDivElement> | undefined;
    onClick?: (() => void) | undefined;
    placeholder?: string;
    required?: boolean;
    select?: boolean;
    size: 'medium' | 'small';
    value?: any;
    variant: 'filled' | 'outlined' | 'standard';
    startIcon: any;
    endIcon: any;
    noCross?: boolean;
    style?: any;
}

declare const GrepsrFormSearch: {
    (props: TextFieldProps): JSX.Element;
    defaultProps: {
        label: null;
        autoFocus: boolean;
        disabled: boolean;
        fullWidth: boolean;
        helperText: string;
        error: boolean;
        id: string;
        name: string;
        placeholder: string;
        type: string;
        multiline: boolean;
        required: boolean;
        select: boolean;
        size: string;
        variant: string;
        endIcon: JSX.Element;
        startIcon: JSX.Element;
    };
    propTypes: {
        id: PropTypes.Validator<string>;
        name: PropTypes.Validator<string>;
        size: PropTypes.Validator<string>;
        type: PropTypes.Validator<string>;
        variant: PropTypes.Validator<string>;
        endIcon: PropTypes.Validator<any>;
        startIcon: PropTypes.Validator<any>;
        style: PropTypes.Requireable<any>;
    };
};

interface IconProps {
    color: "inherit" | "primary" | "success" | "error" | "info" | "warning" | "disabled" | "action" | "secondary" | string | undefined;
    children: ReactNode | any;
    fontSize: "large" | "medium" | "small";
    fontColor?: string | undefined;
}

declare const GrepsrIcon: {
    (props: IconProps): JSX.Element;
    defaultProps: {
        fontSize: string;
        color: string;
        children: string;
    };
    propTypes: {
        children: PropTypes.Validator<NonNullable<PropTypes.ReactNodeLike>>;
        fontSize: PropTypes.Validator<string>;
        color: PropTypes.Validator<string>;
        fontColor: PropTypes.Requireable<string>;
    };
};

interface LinkProps {
    children: ReactNode;
    sx?: Array<Function | object | boolean> | Function | object;
    color?: string;
    underline?: "always" | "hover" | "none";
    variant?: "body" | "button" | "caption" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "inherit" | "overline" | "subtitle1" | "subtitle2";
    component?: ReactNode;
    href: string;
    openNewTab: boolean | undefined;
    [restProps: string]: any;
}

declare const GrepsrLink: {
    ({ children, color, underline, variant, href, openNewTab, ...restProps }: LinkProps): JSX.Element;
    defaultProps: {
        children: string;
        color: string;
        href: string;
        underline: string;
        variant: string;
    };
    propTypes: {
        children: PropTypes.Validator<NonNullable<PropTypes.ReactNodeLike>>;
        color: PropTypes.Requireable<string>;
        typography: PropTypes.Requireable<string>;
        underline: PropTypes.Requireable<string>;
        variant: PropTypes.Requireable<string>;
        href: PropTypes.Validator<string>;
    };
};

interface MenuProps {
    menuLabel: string | undefined;
    open: boolean;
    component?: ElementType | string | any;
    children?: ReactNode;
    anchorEl?: ReactElement | Function | null | any;
    onClick?: MouseEventHandler<HTMLButtonElement> | undefined;
    onClose?: (() => void) | undefined;
    menuIcon?: boolean;
    MenuListProps?: object;
    ariaControls?: string;
    isIconButtonMenu?: boolean | undefined;
    icon?: any;
    size?: 'small' | 'medium' | 'large';
    menuArrlist?: Array<any>[] | undefined;
    setAnchorEl?: any;
    handleMenuChange?: any;
    isMenuForTable?: boolean;
    itemId?: string | number;
    arrMenuOptionsFilter?: Array<any>[];
}

declare const GrepsrMenu: {
    (props: MenuProps): JSX.Element;
    defaultProps: {
        isIconButtonMenu: boolean;
        menuIcon: boolean;
        menuLabel: string;
        menuArrlist: never[];
        open: boolean;
    };
    propTypes: {
        menuLabel: PropTypes.Validator<string>;
        open: PropTypes.Validator<boolean>;
    };
};

interface ModalProps {
    children?: any;
    variant?: 'warning' | 'error' | 'default';
    open?: boolean;
    noCross?: boolean;
    closeAfterTransition?: boolean;
    onClose?: ReactEventHandler<any> | undefined;
    sx?: any;
    ariaLabelledBy?: string | undefined;
    ariaDescribedBy?: string | undefined;
    modalTitle?: ReactNode | undefined;
    fixedHeight?: boolean;
}

declare const GrepsrModal: {
    (props: ModalProps): JSX.Element;
    defaultProps: {};
    propTypes: {};
};

interface MultiselectionProps {
    id?: string;
    label?: string;
    placeholder?: string;
    isHelperText?: boolean;
    helperText?: string;
    sx?: any;
    arrOptions?: Array;
    getOptionLabel?: any;
}

declare const GrepsrMultiselection: {
    (props: MultiselectionProps): JSX.Element;
    defaultProps: {
        id: string;
        label: string;
        placeholder: string;
        isHelperText: boolean;
        helperText: string;
        sx: {
            maxWidth: string;
        };
        arrOptions: never[];
    };
    propTypes: {
        label: PropTypes.Requireable<string>;
        placeholder: PropTypes.Requireable<string>;
        isHelperText: PropTypes.Requireable<boolean>;
        helperText: PropTypes.Requireable<string>;
        sx: PropTypes.Requireable<any>;
        id: PropTypes.Requireable<string>;
        arrOptions: PropTypes.Requireable<any[]>;
        getOptionLabel: PropTypes.Requireable<any>;
    };
};

interface PaginationProps {
    disabled?: boolean;
    page?: number | undefined | any;
    perPageRecord: number | undefined | any;
    totalRecords: number | any | undefined;
    size: "small" | "medium" | "large";
    color: "primary" | "secondary" | "standard";
    shape: "circular" | "rounded";
    variant: "outlined" | "text";
    onChange?: ((e: any) => void) | undefined;
}

declare const GrepsrPagination: {
    (props: PaginationProps): JSX.Element;
    defaultProps: {
        shape: string;
        size: string;
        variant: string;
        disabled: boolean;
        totalRecords: number;
        perPageRecord: number;
    };
    propTypes: {
        shape: PropTypes.Validator<string>;
        size: PropTypes.Validator<string>;
        variant: PropTypes.Validator<string>;
        disbaled: PropTypes.Requireable<boolean>;
        color: PropTypes.Validator<string>;
        page: PropTypes.Requireable<number>;
        perPageRecord: PropTypes.Validator<number>;
        totalRecords: PropTypes.Validator<number>;
    };
};

interface RadioProps {
    checked?: boolean;
    formLabelId?: string;
    ariaLablledBy?: string;
    label?: string;
    value?: string;
    name?: string;
    color: "default" | "primary" | "secondary" | "error" | "info" | "success" | "warning";
    size: "medium" | "small";
    disabled?: boolean;
    disableRipple?: boolean;
    labelPlacement: "end" | "start" | "top" | "bottom" | undefined;
}

declare const GrepsrRadio: {
    ({ formLabelId, label, ariaLablledBy, name, checked, value, size, color, labelPlacement, disableRipple, disabled, }: RadioProps): JSX.Element;
    defaultProps: {
        formLabelId: string;
        ariaLablledBy: string;
        value: string;
        name: string;
        label: string;
        labelPlacement: string;
        checked: boolean;
        disabled: boolean;
        disableRipple: boolean;
        size: string;
        color: string;
    };
    propTypes: {
        labelPlacement: PropTypes.Validator<string>;
        size: PropTypes.Validator<string>;
        color: PropTypes.Validator<string>;
        formLabelId: PropTypes.Requireable<string>;
        ariaLabelledBy: PropTypes.Requireable<string>;
        name: PropTypes.Requireable<string>;
        label: PropTypes.Requireable<string>;
        checked: PropTypes.Requireable<boolean>;
        value: PropTypes.Requireable<string>;
        disabled: PropTypes.Requireable<boolean>;
        disableRipple: PropTypes.Requireable<boolean>;
    };
};

interface radioGroupArr {
    id: number | string;
    label: string | undefined;
    value: string | undefined;
    disabled?: boolean;
}
interface RadioGroupProps {
    ariaLabelledBy?: string;
    defaultValue?: string;
    name?: string;
    labelPlacement: "end" | "start" | "top" | "bottom" | undefined;
    color: "default" | "primary" | "secondary" | "error" | "info" | "success" | "warning";
    row: boolean;
    size: 'medium' | 'small' | 'large';
    radioGroupTitle?: string | undefined;
    radioGroupArr: radioGroupArr[];
}

declare const GrepsrRadioGroup: {
    ({ ariaLabelledBy, defaultValue, name, labelPlacement, color, row, radioGroupTitle, radioGroupArr, size, }: RadioGroupProps): JSX.Element;
    defaultProps: {
        name: string;
        ariaLabelledBy: string;
        labelPlacement: string;
        color: string;
        row: boolean;
        size: string;
        radioGroupTitle: string;
    };
    propTypes: {
        ariaLabelledBy: PropTypes.Requireable<string>;
        defaultValue: PropTypes.Requireable<string>;
        name: PropTypes.Requireable<string>;
        labelPlacement: PropTypes.Validator<string>;
        color: PropTypes.Validator<string>;
        row: PropTypes.Validator<boolean>;
        size: PropTypes.Validator<string>;
        radioGroupTitle: PropTypes.Requireable<string>;
        radioGroupArr: PropTypes.Validator<any[]>;
    };
};

interface SnackbarProps {
    label: string | undefined;
    message: string | undefined | ReactNode;
    color?: "info" | "success" | "error" | "warning" | string;
    severity?: "info" | "success" | "error" | "warning" | string;
    onClick?: (() => void) | MouseEventHandler<any> | undefined;
    onClose: ((event: Event | SyntheticEvent<any, Event>) => void) | undefined;
    open: boolean | undefined;
    action: ReactNode;
    autoHideDuration: number;
    transitionDuration?: number | {
        appear?: number;
        enter?: number;
        exit?: number;
    };
    TransitionComponent: React__default.JSXElementConstructor<TransitionProps & {
        children: React__default.ReactElement<any, any>;
    }> | undefined;
}

declare const GrepsrSnackbar: {
    (props: SnackbarProps): JSX.Element;
    defaultProps: {
        label: string;
        message: string;
        color: string;
        severity: string;
        autoHideDuration: number;
    };
    propTyes: {
        label: PropTypes.Validator<string>;
        message: PropTypes.Validator<string>;
        color: PropTypes.Validator<string>;
        severity: PropTypes.Validator<string>;
        transitionDuration: number;
    };
};

interface tabArray$2 {
    label: string;
    value: string | number;
    icon: ComponentType<SvgIconProps> | ReactJSXElement | null;
}
interface TabProps {
    value?: any;
    onChange: (event: React__default.SyntheticEvent, newValue: string) => void | undefined;
    tabArray: tabArray$2[];
    orientation: "vertical" | "horizontal";
    variant: "fullWidth" | "scrollable" | "standard";
    scrollButtons?: boolean | undefined;
    allowScrollButtonsMobile?: boolean | undefined;
    visibleScrollbar?: boolean | undefined;
    isIcon?: boolean;
}

declare const GrepsrTabs: {
    (props: TabProps): JSX.Element;
    defaultProps: {
        tabArray: {
            id: number;
            value: string;
            label: string;
        }[];
        visibleScrollbar: boolean;
        allowScrollButtonsMobile: boolean;
        scrollButtons: boolean;
        variant: string;
        orientation: string;
        isIcon: boolean;
    };
    propTypes: {
        value: PropTypes.Requireable<any>;
        tabArray: PropTypes.Validator<any[]>;
        orientation: PropTypes.Validator<string>;
        variant: PropTypes.Validator<string>;
        visibleScrollbar: PropTypes.Requireable<boolean>;
        scrollButtons: PropTypes.Requireable<boolean>;
        allowScrollButtonsMobile: PropTypes.Requireable<boolean>;
    };
};

interface tabArray$1 {
    label: string | ReactNode;
    value: string | number;
    content: string | ReactNode | null;
}
interface BlockTabProps {
    value?: any;
    onChange: (event: SyntheticEvent, newValue: string) => void | undefined;
    tabArray: tabArray$1[];
    alignItems: string;
    className?: string | undefined;
    sx?: any;
    hideTabContent?: boolean;
}

declare const GrepsrBlockTabs: {
    (props: BlockTabProps): JSX.Element;
    defaultProps: {
        className: string;
    };
    propTypes: {
        alignItems: PropTypes.Validator<string>;
    };
};

interface TimePickerProps {
    timePickerLabel?: string;
    disabled?: boolean | undefined;
    size?: 'medium' | 'small';
    value?: any;
    onChange?: (value: any, keyboardInputValue?: string | undefined) => void;
}

declare const GrepsrTimePicker: {
    (props: TimePickerProps): JSX.Element;
    defaultProps: {
        timePickerLabel: string;
        disabled: boolean;
        size: string;
    };
    propTypes: {
        timePickerLabel: PropTypes.Requireable<string>;
        disabled: PropTypes.Requireable<boolean>;
        size: PropTypes.Requireable<string>;
    };
};

interface ExtendTooltipProps extends TooltipProps {
    children: ReactNode | Element | any;
    hidden?: boolean;
}

declare const GrepsrTooltip: {
    (props: ExtendTooltipProps): JSX.Element;
    defaultProps: {
        title: string;
        arrow: boolean;
        placement: string;
        children: string;
        followCursor: boolean;
        TransitionComponent: typeof Fade;
        TransitionProps: {
            timeOut: number;
        };
    };
    propTypes: {
        title: PropTypes.Validator<string>;
        children: PropTypes.Validator<NonNullable<PropTypes.ReactNodeLike>>;
        placement: PropTypes.Validator<string>;
        arrow: PropTypes.Requireable<boolean>;
        followCursor: PropTypes.Requireable<boolean>;
        TransitionComponent: PropTypes.Requireable<object>;
        TransitionProps: PropTypes.Requireable<object>;
        hidden: PropTypes.Requireable<boolean>;
    };
};

interface ExtendTypographyProps extends TypographyProps$1 {
    [restProps: string]: any;
    onClick?: any;
}

declare const GrepsrTypography: {
    (props: ExtendTypographyProps): JSX.Element;
    defaultProps: {
        paragraph: boolean;
    };
    propTypes: {
        children: PropTypes.Requireable<string>;
        align: PropTypes.Requireable<string>;
        gutterBottom: PropTypes.Requireable<boolean>;
        noWrap: PropTypes.Requireable<boolean>;
        paragraph: PropTypes.Requireable<boolean>;
        variant: PropTypes.Requireable<string>;
        color: PropTypes.Requireable<string>;
        onclick: PropTypes.Requireable<any>;
    };
};

interface ContainerProps {
    sx?: Array<Function | object | boolean> | Function | object;
    children?: ReactNode;
    maxWidth?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
    fixed?: boolean;
    disableGutters?: boolean;
}

declare const GrepsrContainer: {
    (props: ContainerProps): JSX.Element;
    defaultProps: {
        fixed: boolean;
        disableGutters: boolean;
        maxWidth: string;
        sx: {
            margin: string;
        };
    };
    propTypes: {
        fixed: PropTypes.Requireable<boolean>;
        disableGutters: PropTypes.Requireable<boolean>;
        sx: PropTypes.Requireable<any>;
        maxWidth: PropTypes.Requireable<string>;
    };
};

interface BoxProps {
    sx?: Array<Function | object | boolean> | Function | object | undefined | any;
    children?: ReactNode;
    component?: ElementType | undefined | any | string;
    backgroundColor?: string | any;
    borderColor?: string | any;
    borderWidth?: number;
    borderStyle?: string | any;
    borderRadius?: string | any;
}

declare const GrepsrBox: {
    (props: BoxProps): JSX.Element;
    defaultProps: {
        component: string;
        sx: {};
    };
    propTypes: {
        sx: PropTypes.Requireable<any>;
        component: PropTypes.Requireable<PropTypes.ReactComponentLike>;
    };
};

interface GridProps {
    className?: string;
    columns?: any;
    columnSpacing?: number;
    container?: boolean;
    direction?: "column-reverse" | "column" | "row-reverse" | "row";
    item?: boolean;
    lg?: number;
    xs?: number;
    xl?: number;
    md?: number;
    sm?: number;
    spacing?: number;
    rowSpacing?: number;
    wrap: "nowrap" | "wrap-reverse" | "wrap";
    [restProps: string]: any;
}

declare const GrepsrGrid: {
    (props: GridProps): JSX.Element;
    defaultProps: {
        wrap: string;
    };
    propTypes: {
        wrap: PropTypes.Validator<string>;
    };
};

interface DividerProps {
    absolute?: boolean;
    children?: ReactNode;
    component?: ReactElement | string | any;
    flexItem?: boolean;
    light?: boolean;
    orientation: "vertical" | "horizontal";
    textAlign: 'center' | 'right' | 'left';
    variant: 'fullWidth' | 'inset' | 'middle';
}

declare const GrepsrDivider: {
    (props: DividerProps): JSX.Element;
    defaultProps: {
        absolute: boolean;
        component: string;
        flexItem: boolean;
        light: boolean;
        orientation: string;
        sx: {};
        textAlign: string;
        variant: string;
    };
    propTypes: {
        absolute: PropTypes.Requireable<boolean>;
        component: PropTypes.Requireable<PropTypes.ReactComponentLike>;
        flexItem: PropTypes.Requireable<boolean>;
        light: PropTypes.Requireable<boolean>;
        orientation: PropTypes.Validator<string>;
        sx: PropTypes.Requireable<object>;
        textAlign: PropTypes.Validator<string>;
        variant: PropTypes.Validator<string>;
    };
};

interface SkeletonProps {
    animation?: "pulse" | "wave" | false;
    component?: ReactElement | string | any;
    height: number | string;
    variant?: "circular" | "rectangular" | "rounded" | "text";
    width: number | string;
    backgroundColor?: string;
}

declare const GrepsrSkeleton: {
    (props: SkeletonProps): JSX.Element;
    defaultProps: {
        animation: string;
        component: string;
        height: number;
        variant: string;
        width: number;
    };
    propTypes: {
        animation: PropTypes.Requireable<string>;
        component: PropTypes.Requireable<PropTypes.ReactComponentLike>;
        height: PropTypes.Validator<number>;
        width: PropTypes.Validator<number>;
        variant: PropTypes.Requireable<string>;
    };
};

interface Option$4 {
    label: string;
    value: string;
}
interface DropdownProps$3 {
    value?: string | '' | any | Array<any>[];
    id?: string;
    onChange?: (e: any) => void;
    options?: Array<Option$4>;
    fullWidth?: boolean | undefined;
    size: 'medium' | 'small' | any | undefined;
    multiple?: boolean | undefined;
    renderValue?: (value: string[]) => string[] | undefined;
    sx?: any;
}

declare const GrepsrDropdown: {
    (props: DropdownProps$3): JSX.Element;
    defaultProps: {
        size: string;
    };
    propTypes: {
        size: PropTypes.Validator<string>;
    };
};

interface PageRecordProps {
    label?: string;
    count: number;
    pageNumber: number;
    perPageCount: number;
}

declare const GrepsrPageRecord: {
    (props: PageRecordProps): JSX.Element;
    defaultProps: {
        count: number;
        perPageItem: number;
        pageNumber: number;
        label: string;
    };
    propTypes: {
        count: PropTypes.Requireable<number>;
        pageNumber: PropTypes.Requireable<number>;
        perPageItem: PropTypes.Requireable<number>;
        label: PropTypes.Requireable<string>;
    };
};

interface timelineArray {
    content: ReactNode | any;
    img: any;
    id: string | number;
}
interface TimelineProps {
    timelineArray: timelineArray[];
}

declare const GrepsrTimeline: {
    (props: TimelineProps): JSX.Element;
    defaultProps: {};
    propTypes: {
        timelineArray: PropTypes.Requireable<any[]>;
    };
};

interface AccordionProps {
    accordionSummary?: any;
    disabled?: boolean;
    defaultExpanded?: boolean;
    accordionId?: number;
    accordionKey?: number;
    accordionArray?: TemplateStringsArray[] | undefined;
    accordionTitle?: string;
    accordionDetails?: ReactNode;
    accordionAriacontrols?: string;
}

declare const GrepsrAccordion: {
    (props: AccordionProps): JSX.Element;
    defaultProps: {
        defaultExpanded: boolean;
        disabled: boolean;
        accordionArray: never[];
    };
    propTypes: {
        defaultExpanded: PropTypes.Requireable<boolean>;
        disabled: PropTypes.Requireable<boolean>;
        accordionId: PropTypes.Requireable<number>;
        accordionKey: PropTypes.Requireable<number>;
        accordionArray: PropTypes.Requireable<any[]>;
        accordionTitle: PropTypes.Requireable<string>;
        accordionDetails: PropTypes.Requireable<PropTypes.ReactNodeLike>;
        accordionAriacontrols: PropTypes.Requireable<string>;
    };
};

interface ColumnsProps<T> {
    key: string | ReactNode | any;
    title: string | ReactNode | any;
    width?: number;
    id?: number | string;
    render?: (column: ColumnsProps<T>, item: T) => void;
}
interface DataTableProps<T> {
    sx?: any;
    disabled?: boolean;
    data: T[];
    columns: ColumnsProps<T>[];
    menu?: any;
}

declare function GrepsrDataTable<T>({ data, columns, sx, }: DataTableProps<T>): JSX.Element;

interface DrawerProps {
    open?: boolean | any;
    anchor: "bottom" | "left" | "right" | "top";
    hideBackdrop?: boolean;
    children?: ReactNode;
    sx?: any;
    className?: any;
    onClose?: () => void;
    onClick?: () => void;
    closeIconNode?: ReactNode;
    isCloseIcon?: boolean;
    color: string | "primary" | "success" | "error" | "info" | "warning" | "inherit";
    variant: "contained" | "outlined" | "text";
    size: "small" | "medium" | "large";
    disabled?: boolean;
    drawerSidebarTitle?: string | any;
}

declare const GrepsrDrawer: {
    (props: DrawerProps): JSX.Element;
    defaultProps: {
        anchor: string;
        color: string;
        variant: string;
        size: string;
    };
    propTypes: {
        anchor: PropTypes.Validator<string>;
        color: PropTypes.Validator<string>;
        size: PropTypes.Validator<string>;
        variant: PropTypes.Validator<string>;
    };
};

interface GlobalSearchProps {
    label?: string;
    ariaLabelledBy?: string;
    ariaDescribedby?: string;
    onClick?: React__default.MouseEventHandler<HTMLAnchorElement> | undefined;
    onClose?: (() => void | undefined) | undefined;
    open?: boolean | undefined;
    globalSearchInput?: ReactNode;
    globalSearchIcon?: ReactNode;
    globalSearchClose?: ReactNode;
    children?: ReactNode;
}

declare const GrepsrGlobalSearch: {
    (props: GlobalSearchProps): JSX.Element;
    defaultProps: {
        ariaDescribedBy: string;
        ariaLabelledBy: string;
    };
    propTypes: {
        ariaLabelledBy: PropTypes.Requireable<string>;
        ariaDescribedby: PropTypes.Requireable<string>;
    };
};

interface NavigationProps {
    isSecondaryNav?: boolean;
    open?: boolean;
    primaryDrawerList?: Array<string>[] | any | undefined;
    secondaryDrawerList?: Array<string>[] | any | undefined;
    className?: any;
    primarySimpleDrawerWidth?: number;
    secondaryDrawerwidth?: number;
    secondaryPrimaryDrawerWidth?: number;
    navMainHeight?: number;
    children?: any;
}

declare function GrepsrNavigation(props: NavigationProps): JSX.Element;
declare namespace GrepsrNavigation {
    var defaultProps: {
        isSecondaryNav: boolean;
        primarySimpleDrawerWidth: number;
        secondaryDrawerwidth: number;
        secondaryPrimaryDrawerWidth: number;
        children: JSX.Element;
    };
    var propTypes: {
        isSecondaryNav: PropTypes.Requireable<boolean>;
        primarySimpleDrawerWidth: PropTypes.Requireable<number>;
        secondaryDrawerwidth: PropTypes.Requireable<number>;
        secondaryPrimaryDrawerWidth: PropTypes.Requireable<number>;
        children: PropTypes.Requireable<any>;
    };
}

interface SummaryCardProps {
    title?: ReactNode;
    sx?: any;
    className?: string;
    children: ReactNode;
    component?: ElementType;
    action?: ReactNode;
    actionCardHeader?: ReactNode | null;
    cardHeaderIcon?: ReactNode | null;
    cardHeaderIconAlt?: string | null;
    src?: string | any | undefined;
}

declare const GrepsrSummaryCard: {
    (props: SummaryCardProps): JSX.Element;
    defaultProps: {
        children: JSX.Element;
    } | {
        children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
    };
};

interface WidgetProps {
    title: string;
    count?: number;
    caption: string;
    content: string;
    rowSpacing: number;
    columnSpacing: number;
}

declare const GrepsrWidget: {
    (props: WidgetProps): JSX.Element;
    defaultProps: {
        title: string;
        count: number;
        caption: string;
        content: string;
        rowSpacing: number;
        columnSpacing: number;
    };
    propTypes: {
        title: PropTypes.Validator<string>;
        count: PropTypes.Requireable<number>;
        caption: PropTypes.Validator<string>;
        content: PropTypes.Validator<string>;
        rowSpacing: PropTypes.Validator<number>;
        columnSpacing: PropTypes.Validator<number>;
    };
};

interface GrepsrMiniViewBoxProps {
    children: ReactNode;
    label?: ReactElement | string | ReactNode | any;
    color?: "info" | "success" | "error" | "warning" | "inherit" | any;
    backgroundColor?: any;
    borderColor?: any;
    textColor?: any;
    variant?: "outlined" | "contained" | "text";
    [restProps: string]: any;
    size?: "small" | "medium" | "large";
    sx?: any;
    startIcon?: ReactNode | any;
    endIcon?: ReactNode | any;
    disabled?: boolean;
    isDropdown?: boolean;
    onClick?: (event?: any) => void;
}

declare const GrepsrMiniViewBox: {
    (props: GrepsrMiniViewBoxProps): JSX.Element;
    defaultProps: {
        label: string;
    };
    propTypes: {
        label: PropTypes.Requireable<string>;
    };
};

interface GrepsrScheduleTimelineProps {
    steps: Array<string>[];
    label: React.ReactElement | string;
    title: string;
    color?: "inherit" | "primary" | "success" | "error" | "info" | "warning";
    [restProps: string]: any;
    titleFontSize?: number;
    titleFontWeight?: string;
    iconButtonSize?: "small" | "medium" | "large";
    variant?: "outlined" | "contained" | "text";
}

declare const GrepsrScheduleTimeline: {
    (props: GrepsrScheduleTimelineProps): JSX.Element;
    defaultProps: {
        label: string;
        title: string;
        titleFontWeight: string;
        titleFontSize: number;
        iconButtonSize: string;
        steps: never[];
    };
    propTypes: {
        label: PropTypes.Validator<string>;
        title: PropTypes.Validator<string>;
        color: PropTypes.Requireable<string>;
        variant: PropTypes.Requireable<string>;
        steps: PropTypes.Validator<any[]>;
        iconButtonSize: PropTypes.Requireable<string>;
    };
};

interface GrepsrSecondaryCardProps {
    leftHeader?: ReactNode | string | any;
    rightHeader?: Date | any;
    children?: ReactNode | any;
    iconImg?: string | any | null;
    sx?: any;
    borderBottom?: any;
}

declare const GrepsrSecondaryCard: {
    (props: GrepsrSecondaryCardProps): JSX.Element;
    defaultProps: {};
    propTypes: {};
};

interface HighchartsProps {
    options: any;
}

declare const GrepsrHighcharts: {
    (props: HighchartsProps): JSX.Element;
    defaultProps: {
        options: {
            title: {
                text: string;
            };
            series: {
                data: number[];
            }[];
        };
    };
    propTypes: {
        options: PropTypes.Validator<Object>;
    };
};

interface EmptyStateProps {
    title: string | ReactNode;
    subTitle: string | ReactNode;
    emptyImageSrc: string;
    emptyImageAlt: string;
    isSmImg?: boolean;
}

declare const GrepsrEmptyState: {
    ({ title, subTitle, emptyImageAlt, emptyImageSrc, isSmImg, }: EmptyStateProps): JSX.Element;
    defaultProps: {
        title: string;
        emptyImageAlt: string;
        emptyImageSrc: string;
        subTitle: string;
    };
    propTypes: {
        title: PropTypes.Requireable<string>;
        subTitle: PropTypes.Requireable<string>;
        emptyImageAlt: PropTypes.Requireable<string>;
        emptyImageSrc: PropTypes.Requireable<string>;
    };
};

interface tabArray {
    label: string | ReactNode;
    value: string | number;
    content: string | ReactNode;
}
interface BlockTabTableProps {
    value?: any;
    onChange: (event: SyntheticEvent, newValue: string) => void | undefined;
    tabArray: tabArray[];
    alignItems: string;
    className?: string | undefined;
    sx?: any;
    children?: ReactNode;
}

declare const GrepsrBlockTabsTable: {
    (props: BlockTabTableProps): JSX.Element;
    defaultProps: {
        className: string;
    };
    propTypes: {
        alignItems: PropTypes.Validator<string>;
    };
};

interface GrepsrCustomButtonProps {
    label?: string;
    color?: "info" | "success" | "error" | "warning" | "inherit" | "custom" | any;
    backgroundColor?: any;
    borderColor?: any;
    textColor?: any;
    sx?: any;
}

declare const GrepsrCustomButton: {
    (props: GrepsrCustomButtonProps): JSX.Element;
    defaultProps: {
        label: string;
    };
    propTypes: {
        label: PropTypes.Requireable<string>;
        color: PropTypes.Requireable<string>;
    };
};

interface Option$3 {
    id: number;
    defaultChecked: boolean;
    label: string;
}
interface AdvancedDropProps {
    label: string;
    open?: boolean;
    value?: string | '' | any | Array<any>[];
    id: string | number | undefined;
    onChange?: (e: any) => void;
    size?: 'small' | 'medium';
    defaultChecked: boolean;
    showSelectAll?: boolean;
    placeholder?: 'project' | 'items';
    btnLabel1?: string;
    btnLabel2?: string;
    btn1Click?: (l: Option$3[]) => void;
    btn2Click?: () => void;
    handleOpen?: () => void;
    dropData?: Option$3[];
    sx?: any;
    selectedItems?: any;
    onSearch?: (l: any) => void;
    showSearch?: boolean;
    isLoading?: boolean;
    showId?: boolean;
}

declare const GrepsrAdvancedDropDown: React__default.FC<AdvancedDropProps>;

interface Options {
    label: string | any;
    value: string | any;
}
interface AdvancedDropdownProps {
    label?: string;
    IconComponent?: ElementType | any;
    fullWidth?: boolean | undefined;
    options?: Options[] | undefined;
    size?: 'medium' | 'small';
    sx?: any;
    value?: any | string[];
    onChange?: ((event: SelectChangeEvent<string[]>) => void) | undefined;
}

declare const SuperAdvancedDropdown: {
    (props: AdvancedDropdownProps): JSX.Element;
    defaultProps: {
        label: string;
    };
    propTypes: {
        label: PropTypes.Requireable<string>;
    };
};

interface Child$1 {
    id: number | string;
    defaultChecked: boolean;
    label: string;
}
interface Parent$1 {
    id: number | string;
    label: string;
    children: Child$1[];
}
interface DropdownProps$2 {
    dataSources: Parent$1[];
    label: string;
    size?: 'small' | 'medium';
    applyButton?: (l: any) => void;
    emptyButton?: (l: any) => void;
    handleOpen?: () => void;
    open?: boolean;
    handleCancel?: () => void;
    showSelectAll?: boolean;
}

declare const GrepsrDynamicDropDown: React__default.FC<DropdownProps$2>;

interface Option$2 {
    created?: string;
    id: number;
    modified?: string;
    name: string;
    totalUsers?: number;
}
interface SearchDropProps {
    label: string;
    size?: 'small' | 'medium';
    dropData: Option$2[];
    open?: boolean;
    onSearch: (l: any) => void;
    handleClose?: (l: any) => void;
    handleOpen?: () => void;
    onSelect?: (l: any) => void;
    sx?: any;
    selectedValue?: any;
    setHeight?: number;
    showNoData?: string;
    isLoading?: boolean;
    showId?: boolean;
}

declare const GrepsrSearchDropDown: ({ label, size, open, dropData, onSearch, handleClose, handleOpen, sx, onSelect, selectedValue, setHeight, showNoData, isLoading, showId, }: SearchDropProps) => JSX.Element;

interface Child {
    id: number | string;
    defaultChecked: boolean;
    label: string;
}
interface Parent {
    id: number | string;
    label: string;