import * as React$1 from 'react';
import React__default, { ReactNode, FC, RefObject, LegacyRef, CSSProperties, ReactElement, Ref, ComponentProps, Component, ErrorInfo } from 'react';
import * as react_jsx_runtime from 'react/jsx-runtime';
import * as LazyLoad from 'react-window';
export { LazyLoad };
import * as Form from 'react-hook-form';
import * as DNDCore from '@dnd-kit/core';
import * as DNDSortable from '@dnd-kit/sortable';
import * as DNDUtilities from '@dnd-kit/utilities';
import * as DNDModifiers from '@dnd-kit/modifiers';
import ReCAPTCHA from 'react-google-recaptcha';
export { default as Janus } from 'janus-gateway';
export { default as adapter } from 'webrtc-adapter';

type DynamicObj = {
    [key: string]: any;
};
interface CreateVariableProps {
    /**
     * Open Create variable Slider
     */
    isOpen: boolean;
    /**
     * Value for the variable name
     */
    variableName: string;
    /**
     * Value for the variable to be created
     */
    variableValue: string;
    /**
     * List for the variable types
     */
    variableTypesList: DynamicObj[];
    /**
     * Selected variable type
     */
    selectedVariableType: DynamicObj;
    /**
     * Function to handle variable type change
     * @param option
     * @returns
     */
    onVariableTypeChange: (option: DynamicObj) => void;
    /**
     * Function to handle close
     */
    onClose?: () => void;
    /**
     * onChange of name
     */
    onNameChange: (value: string) => void;
    /**
     * onChange of value
     */
    onValueChange: (value: string, dropdownItem?: DynamicObj) => void;
    /**
     * Hide value
     */
    hideValue: boolean;
    /**
     * onChange for hide value
     */
    onHideChange: (value: boolean) => void;
    /**
     * Function to handle submit
     */
    handleSubmit: () => void;
    /**
     * verify which drawer is open, create or edit
     */
    mode?: 'create' | 'edit';
    /**
     * Disable the checkbox
     */
    disabled?: boolean;
    /**
     * Hide or show dropdown for hash values
     */
    isHash?: boolean;
    /**
     * Stores the files data
     */
    dataFiles?: DynamicObj[];
    /**
     * Show or hide password icon
     */
    showHidePasswordIcon?: boolean;
    /**
     * Show placeholder text
     */
    placeholder?: string;
}

interface ButtonProps {
    /**
     * Variant of the button
     */
    variant: 'primary' | 'secondary' | 'tertiary' | 'delete' | 'warning' | 'custom' | 'danger';
    /**
     * What background color to use
     */
    backgroundColor?: string;
    /**
     * What border color to use
     */
    border?: string | number;
    /**
     * What border color to use
     */
    size?: 'small' | 'medium' | 'large';
    /**
     * Button contents
     */
    label?: string;
    /**
     * Type of the button
     */
    type?: 'button' | 'submit';
    disabled?: boolean;
    /**
     * Optional click handler
     */
    onClick?: (event: React.MouseEvent<HTMLButtonElement, MouseEvent>) => void;
    /**
     * Optional click handler for Copying the value
     */
    onCopy?: (event: React.ClipboardEvent<HTMLButtonElement>) => void;
    /**
     * Button content
     */
    children?: ReactNode;
    /**
     * Button id
     */
    id?: string;
    /**
     * onSubmit function handler
     */
    onSubmit?: (event: React.MouseEvent<HTMLButtonElement, MouseEvent>) => void;
    /**
     * react ref for the button
     */
    ref?: any;
    /**
     * Classname for the button
     */
    className?: string;
    /**
     * Additional styles for the button
     */
    style?: React.CSSProperties;
    /**
     * 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';
    transparentBackground?: boolean;
    /**
     * form to accept form id in string
     */
    form?: string;
    /**
     * Is the Type ChooseFile for the button
     */
    isChooseFile?: boolean;
    /**
     * Custom Width for the button
     */
    buttonWidth?: string;
    /**
     * Custom Height for the button
     */
    buttonHeight?: string;
    /**
     * selectedfile object will be send.
     */
    selectedFile?: File | DynamicObj | null;
    /**
     * handleCloseIcon function will set to the initial state .
     */
    handleCloseIcon?: () => void;
    /**
     * create custom button font size .
     */
    fontSize?: number;
    /**
     * create custom button style .
     */
    typographyStyle?: React.CSSProperties;
    iconColor?: string;
    /**
     * Is the Type ChooseFile Action Mandatory for the button
     */
    isMandatory?: boolean;
}

declare const Button: React$1.ForwardRefExoticComponent<Omit<ButtonProps, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;

interface BtnPropsCommon {
    /**
     * Label for the button
     */
    label?: string;
    /**
     * Boolean value to disable the button
     */
    disabled?: boolean;
    /**
     * Onclick function for button
     */
    onClick?: () => void;
    /**
     * Button type
     * @default 'button'
     * @example 'submit'
     * @example 'button'
     */
    type?: 'button' | 'submit';
    /**
     *  form to accept id of form in string format
     */
    form?: string;
}
interface DrawerProps {
    /**
     * To Open the Drawer
     */
    isOpen: boolean;
    /**
     * To Expand the Drawer
     */
    _isExpanded?: boolean;
    /**
     * To show and  hide the back button of the Drawer
     */
    isBackButtonVisible?: boolean;
    /**
     * To show and  hide the close button of the Drawer
     */
    _isCloseModalButtonVisible?: boolean;
    /**
     * Function to close the drawer
     */
    onClose?: () => void;
    /**
     * Function to go back in the drawer
     */
    onBackButtonClick?: () => void;
    /**
     * Size of the drawer medium = 550px large = 850px
     */
    size?: 'small' | 'medium' | 'large' | 'x-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;
    /**
     * To show the transition effect while the drawer comes
     */
    showTransition?: boolean;
    /**
     * Primary | Success button props
     */
    primaryButtonProps?: BtnPropsCommon;
    /**
     * Secondary | Cancel button props
     */
    secondaryButtonProps?: BtnPropsCommon;
    /**
     * Left side Primary Button | Cancel button props
     */
    leftPrimaryButtonProps?: BtnPropsCommon;
    /**
     * Left side Secondary | Cancel button props
     */
    leftSecondaryButtonProps?: BtnPropsCommon;
    /**
     * Left side Tertiary Button | Help button props
     */
    leftTertiaryButtonProps?: BtnPropsCommon;
    /**
     * Right side Tertiary Button | More Info button props
     */
    rightTertiaryButtonProps?: 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;
    /**
     * To show or hide the header
     */
    showHeader?: boolean;
    /**
     *  Custom back button icon
     * The icon to display for the back button.
     * If not provided, a default icon will be used.
     */
    backButtonIcon?: ReactNode;
    /**
     * Callback function when the close icon is clicked
     */
    onCloseIconClick?: () => void;
    /**
     * Custom header for the drawer, replacing the default header.
     * If provided, this will render in place of the default header.
     */
    customHeader?: ReactNode;
    /**
     * Custom footer for the drawer, replacing the default footer.
     * If provided, this will render in place of the default footer.
     */
    customFooter?: ReactNode;
    /**
     * Custom z-index for the drawer
     */
    zIndex?: number;
    /**
     * Custom top for the drawer
     */
    top?: string;
    /**
     * Height of the drawer
     */
    height?: string;
    /**
     *
     * width of the drawer
     */
    width?: string;
    /**
     * Position from right
     */
    right?: string | number;
    /**
     * Custom overflow for the drawer
     */
    overflow?: string;
    /**
     * Callback function returns a boolean value when the drawer is collapsed.
     */
    onCollapse?: (value: boolean) => void;
    /**This optional boolean prop determines whether the drawer body displays a scrollbar when its content overflows. */
    isScrollBar?: boolean;
    /**
     *To  Close the drawer when clicking outside of it.
     */
    isClickOutside?: boolean;
    ignoreRefs?: Array<React.RefObject<HTMLElement>>;
}

declare const Drawer: FC<DrawerProps>;

interface IconProps$2 {
    name: string;
    className?: string;
    height?: number;
    width?: number;
    color?: string;
    onClick?: (data?: any) => void;
    hoverEffect?: boolean;
    isSelected?: boolean;
    disabled?: boolean;
    variant?: 'dark' | 'light' | 'danger';
    x?: string;
    y?: string;
    chartIcon?: boolean;
    tabIndex?: number;
    toolTipTitle?: string;
    cursorType?: string;
}

declare const Icon: React$1.ForwardRefExoticComponent<IconProps$2 & React$1.RefAttributes<HTMLSpanElement>>;

interface AccordionProps {
    /**
     * Accordion Header Title
     */
    headerTitle: string | JSX.Element;
    /**
     * Content that to be shown while Accordion is expanded
     */
    accordionContent: ReactNode;
    /**
     * Custom color for the Accordion header
     */
    color?: string;
    /**
     * Minimum height for the Accordion
     */
    minHeight?: string;
    /**
     * Property to disable accordion
     */
    disable?: boolean;
    /**
     * Info message to user for disabling accordion
     */
    disableInfoMessage?: string;
    /**
     * Icon name for the Accordion state like expand and collapse
     */
    accordionStateIconName?: string;
    /**
     * Accordion collapse and expand Icon width
     */
    AccordionStateIconWidth: number;
    /**
     * Accordion collapse and expand Icon height
     */
    AccordionStateIconHeight: number;
    /**
     * Optional props for initial state of Accordion
     */
    isExpand?: boolean;
    /**
     * Callback function for the accordion header click
     */
    onClick?: () => void;
    /**
     * Providing className for Styles
     */
    className?: string;
    iconColor?: string;
    highlightText?: string;
}

/**
 * Accordion UI component
 */
declare const Accordion: ({ highlightText, headerTitle, color, minHeight, accordionContent, disable, disableInfoMessage, accordionStateIconName, AccordionStateIconWidth, AccordionStateIconHeight, isExpand, onClick, className, iconColor, }: AccordionProps) => react_jsx_runtime.JSX.Element;

type OptionValue$4 = any;
interface Option$6 {
    [key: string]: OptionValue$4;
}
interface MultiSelectProps {
    options: Option$6[];
    type?: 'email' | 'text';
    label: string;
    selectedOptions?: Option$6[];
    disabled?: boolean;
    onSearch?: (searchedKeyword: string) => void;
    onChange?: (selectedOptions: Option$6[]) => void;
    acceptNewOption?: boolean;
    zIndex?: number;
    required?: boolean;
    errorMessage?: string;
    withSelectButton?: boolean;
    onSelectButtonClick?: (selectedOptions: Option$6[]) => void;
    displayCount?: boolean;
    isAllSelected?: boolean;
    onToggleAllSelect?: (checkedState: boolean) => void;
    displayAllSelectedAsText?: boolean;
    placeholderForSearching?: string;
    isAllSelect?: boolean;
    /**  Default is default. choose labels variant if you are using this component for labels dropdown or choose machines if you are using this component in parallel  */
    variant?: 'default' | 'labels' | 'machines';
    /** Pass the function what to do upon clicking label plus icon  */
    onLabelPlusIconClick?: (_enteredKeyword: string) => Promise<void>;
    /** classname to handle styling wrt to multiselect div and and labelplus icon */
    className?: string;
    labelAccessor?: string;
    valueAccessor?: string;
    searchAccessor?: string;
    onEnter?: (newOption: string) => boolean;
    loadMoreOptions?: () => void;
    maxVisibleChips?: number;
    onBlur?: () => void;
    /** default max height is 160px, give max dropdown height while using jsx or want to control how many max options you want to show  */
    maxDropdownHeight?: number;
    /**
     * Ref for select option dropdown
     */
    dropdownContainerRef?: RefObject<HTMLDivElement>;
    noResultsMessage?: string;
    chipAccessor?: string;
}

declare const MultiSelect: ({ options, type, selectedOptions, onChange, acceptNewOption, zIndex, label, onSearch, required, disabled, errorMessage, displayCount: initialDisplayCount, isAllSelected, onToggleAllSelect, displayAllSelectedAsText, isAllSelect, placeholderForSearching, variant, onLabelPlusIconClick, className, onSelectButtonClick, labelAccessor, valueAccessor, searchAccessor, withSelectButton, loadMoreOptions, onEnter, maxVisibleChips, onBlur, maxDropdownHeight, dropdownContainerRef, noResultsMessage, chipAccessor, }: MultiSelectProps) => react_jsx_runtime.JSX.Element;

interface ToasterProps {
    /**Boolean value to handle state of toaster. */
    isOpen: boolean;
    /**Variant for different type of toast message. */
    variant: 'success' | 'warning' | 'danger' | 'info' | 'confirm' | 'alert';
    /**Title of the toaster  */
    toastTitle: string;
    /**Message for the toaster. */
    toastMessage?: string;
    /**Function to call upon clicking the close icon or cancel button. */
    onCancelClick?: () => void;
    /**Function to call when confirmation the prompt. */
    onConfirmation?: () => void;
    /**Duration in ms for which toaster will stay on the screen */
    displayDuration?: number;
    /**Confirmation text for variant confirm. */
    confirmationText?: string;
    /**z-index value */
    zIndex?: number;
}

declare const Toaster: React__default.FC<ToasterProps>;

interface ContainerProps {
    /**
     * The content to be displayed inside the container.
     * Typically consists of rows and columns.
     *
     * @type {ReactNode}
     */
    children: ReactNode;
    /**
     * Determines if the container should be fluid (expand to 100% width) or fixed width.
     *
     * @default false
     * @type {boolean}
     */
    fluid?: boolean;
    /**
     * Defines the gap (spacing) between the rows and columns inside the container.
     * Accepts any valid CSS size value (e.g., '10px', '1rem', etc.).
     *
     * @default '0px'
     * @type {string}
     */
    gap?: string;
    /**
     * Classname for Container
     * @default ''
     * @type {string}
     */
    className?: string;
}
interface RowProps {
    /**
     * The content to be displayed inside the row, usually consisting of columns (`<Col />`).
     *
     * @type {ReactNode}
     */
    children: ReactNode;
    /**
     * The gap (spacing) between columns within the row.
     * Accepts any valid CSS size value.
     *
     * @default '0px'
     * @type {string}
     */
    gap?: string;
    /**
     * @default ''
     * @type string
     */
    className?: string;
}
interface ColProps {
    /**
     * The content to be displayed inside the column.
     *
     * @type {ReactNode}
     */
    children: ReactNode;
    /**
     * Defines the width of the column as a fraction of 12 (for a 12-column grid system).
     * For example, `size={6}` would make the column take up half the width of the row.
     *
     * @default 12
     * @type {number}
     */
    size?: number;
    /**
     * @default  ''
     * @type string
     *
     */
    className?: string;
}

declare const Container: React__default.FC<ContainerProps>;
declare const Row: React__default.FC<RowProps>;
declare const Col: React__default.FC<ColProps>;

interface ToggleProps {
    /**
     * Optional onChange handler
     */
    onChange?: (event: React.MouseEvent<HTMLInputElement, MouseEvent>) => void;
    /**
     * Optional disabled state
     */
    disabled?: boolean;
    /**
     * Optional checked state
     */
    checked?: boolean;
    /**
     * Optional id
     */
    id?: string;
    /**
     * What background color to occur upon toggled
     */
    variant?: 'primary' | 'secondary';
    /**
     * Defines the size of the toggle
     */
    size?: 'small' | 'medium' | 'large';
    /**
     * Optional icon configuration for the toggle. This allows for custom icons to be used for both the checked and unchecked states.
     *
     * @property checked - Icon configuration for the checked state.
     * @property unchecked - Icon configuration for the unchecked state.
     *
     * @example
     * {
     *   checked: { name: 'checked-icon', width: 24, height: 24 },
     *   unchecked: { name: 'unchecked-icon', width: 24, height: 24 }
     * }
     */
    icon?: {
        checked?: {
            name: string;
            width: number;
            height: number;
        };
        unchecked?: {
            name: string;
            width: number;
            height: number;
        };
    };
}

declare const Toggle: React__default.FC<ToggleProps>;

interface ChipsProps {
    /**
     * The text to be displayed on the Chip.
     */
    label: string;
    /**
     * The text to be displayed on hover.
     */
    fullText?: string;
    /**
     * The variant of the Chip.
     */
    variant?: 'primary' | 'success' | 'error' | 'warning' | 'custom' | 'public' | 'partial-public' | 'private' | 'disabled' | 'count';
    /**
     * The callback function to be executed when the Chip is clicked.
     */
    labelWidth?: number;
    fullTextWidth?: number;
    onClick?: () => void;
}

declare const Chip: ({ label, fullText, variant, labelWidth, fullTextWidth, onClick, }: ChipsProps) => react_jsx_runtime.JSX.Element;

interface TooltipProps {
    /**
     * The text or content to be displayed inside the tooltip.
     * This can be a string or any React node.
     */
    title?: string | React.ReactNode;
    /**
     * The children over which the tooltip will be displayed.
     * Typically a button or any other interactive element.
     */
    children: React.ReactNode;
    /**
     * The placement of the tooltip relative to the children.
     * Defines where the tooltip appears: top, bottom, left, right, etc.
     *
     * @default 'bottom'
     */
    placement?: 'top' | 'bottom' | 'left' | 'right' | 'top-start' | 'top-end' | 'bottom-start' | 'bottom-end';
    /**
     * Whether the tooltip is disabled.
     * If true, the tooltip will not be displayed.
     *
     * @default false
     */
    disabled?: boolean;
    /**.
     * Z-Index is by default 99
     *
     * @default 99
     */
    zIndex?: number | string;
    style?: React.CSSProperties;
    /**
     * For JSX elements
     */
    as?: React.ElementType;
}

declare const Tooltip: React__default.FC<TooltipProps>;

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;
    /**
     * variants to set color/style of the input field
     */
    variant?: 'default' | 'primary';
    /**
     * type to set color/style of the input field
     */
    type: 'text' | 'password' | 'number' | 'email' | 'url' | 'time';
    /**
     * error | If true, error message will be displayed
     */
    error?: boolean;
    /**
     * helperText | error, success, warning message to be shown
     */
    helperText?: string;
    /**
     * isHelperTextRequired for Helper/Info message to be shown
     */
    isHelperTextRequired?: 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;
    /**
     * noBorder prop 'true' removes border of input
     */
    noBorder?: boolean;
    /**
     * onChange, onKeyDown, onBlur, onFocus actions
     */
    onChange?: (event: React.ChangeEvent<HTMLInputElement>, item?: any) => void;
    onKeyDown?: (event: React.KeyboardEvent<HTMLInputElement>) => void;
    onBlur?: (event: React.FocusEvent<HTMLInputElement>) => void;
    onFocus?: (event: React.FocusEvent<HTMLInputElement>) => void;
    onClick?: (event: React.MouseEvent<HTMLInputElement>) => void;
    onKeyUp?: (event: React.KeyboardEvent<HTMLInputElement>) => void;
    /**
     * id to select the input field uniquely
     */
    id?: string;
    /**
     * if on, suggestion popup will be displayed
     */
    autoComplete?: 'on' | 'off' | 'new-password';
    /**
     * if true, input field is in autofocus state
     */
    autoFocus?: boolean;
    /**
     * minimum and maximum values for the number type input field and their functions
     */
    minValue?: string | number;
    maxValue?: string | number;
    /**
     * background of the input field prop
     */
    transparentBackground?: boolean;
    /**
     * size for the input field
     */
    size?: 'small' | 'medium';
    /**
     * isLabelRequired for the input field without label, showing placeholder
     */
    isLabelRequired?: boolean;
    /**
     * optional '15px' reserve helperText space prop for the input field
     */
    reserveHelperTextSpace?: boolean;
    setUpdatedNumberValue?: (value: number) => void;
    /**
     * Flag to determine if error messages and error styling should be displayed immediately.
     */
    displayErrorImmediately?: boolean;
    /**
     * Flag to determine if search icon for input needs to displayed or not.
     */
    showSearchIcon?: boolean;
    /**
     * Icon props.
     */
    searchIconProps?: IconProps$2;
    /**
     * Function to search url on icon click.
     */
    handleSearchIconClick?: (e: any) => void;
    /**
     * Allows the user to copy the content but not edit it
     */
    readOnly?: boolean;
    onPaste?: (event: React.ClipboardEvent<HTMLInputElement>) => void;
    /**
     * Reset min and max value for the input field on blur
     */
    adjustToValidRange?: boolean;
    /**
     * pattern for input component
     */
    pattern?: string;
    /**
     * background for handle input component background
     */
    background?: string;
    /**
     * Prevents the user from entering values greater than the specified maxValue.
     */
    disableAfterMaxValueReached?: boolean;
    helperTextWidth?: string | number;
}

declare const Input: React$1.ForwardRefExoticComponent<InputProps & React$1.RefAttributes<HTMLInputElement>>;

type Status$1 = {
    status: 'Passed' | 'Failed' | 'Warning' | 'Skipped' | 'passed' | 'failed' | 'warning' | 'skipped';
    value: number;
};
interface RadialChartProps {
    radius: number;
    lineWidth: number;
    statusValues: Status$1[];
    onClick?: (status: Status$1) => void;
    fontSize: number;
    gap?: number;
}

declare const RadialChart: React__default.FC<RadialChartProps>;

interface ExpandableMenuProps {
    /**
     * mandatory | label for the expandable menu
     */
    label: string;
    /**
     * optional | Icon to describe direction of expansion
     */
    icon?: React.ReactNode;
    /**
     * optional | variant of the menu
     */
    variant?: 'primary';
    /**
     * optional | size of the expandable menu
     */
    size?: 'medium';
    /**
     * optional | disable to disable the menu and prevent click events but not hover event
     */
    disable?: boolean;
    /**
     * Mandatory |  sub menus to be shown inside  expandable menu
     */
    subMenus: string[];
    /**
     * optional | selected sub menu of the expandable menu
     */
    selectedMenu?: string;
    /**
     * optional | onSubMenuClick event to perform action on click of sub menu
     */
    onSubMenuClick?: (subChip: any) => void;
    menuExpandStatus?: boolean;
}

declare const ExpandableMenu: React.FC<ExpandableMenuProps>;

interface SelectProps$1 {
    label?: string;
    showLabel?: boolean;
    /**
     * Provide the boolean value if arrow icon is reuired or not
     */
    showArrowIcon?: boolean;
    optionsList: Option$5[];
    selectedOption: Option$5;
    onChange: (option: Option$5) => void;
    errorMsg?: string;
    className?: string;
    optionZIndex?: number;
    disabled?: boolean;
    borderRadius?: string;
    showBorder?: boolean;
    required?: boolean;
    /**
     * optionsRequired:false prop removes options from dropdown & shows static label only
     */
    optionsRequired?: boolean;
    selectedOptionColor?: string;
    labelAccessor?: string;
    valueAccessor?: string;
    height?: number;
    width?: number | string;
    onBlur?: () => void;
    disableInput?: boolean;
    showIcon?: boolean;
    iconName?: string;
    /**
     * Provide the placehoder for the select
     */
    placeHolder?: string;
    /**
     * Provide the boolean value if tooltip is reuired or not
     */
    showToolTip?: boolean;
    /**
     * Provide the background color for the select label on the hover state
     */
    labelBackgroundColor?: string;
    /**
     * To close the modal in the select dropdown
     */
    onCancelModal?: () => void;
    /**
     * To close the modal in the select dropdown
     */
    onSaveModal?: () => void;
    /**
     * Pass the custom Jsx for the Modal
     */
    modalJSXProps?: ReactNode;
    /**
     * Pass the recurrence boolean for the exeception cases
     */
    recurrence?: boolean;
    /**
     * Toggles the visibility of dropdown options, when called, toggles the dropdown visibility
     */
    showOptions?: {
        open: boolean;
        toggle: boolean;
    };
    /**
     * Tooltip for input data
     */
    tooltip?: boolean;
    /**
     * Provide the boolean value if close icon is reuired or not
     */
    showClearIcon?: boolean;
    /**
     * Handel function for clearing the selected data
     */
    handelClear?: () => void;
    /**
     * Handle background color
     */
    background?: string;
    /**
     * No Result message
     */
    noResultsMessage?: string;
    /**
     * Ref for select option dropdown
     */
    dropDownRef?: RefObject<HTMLDivElement>;
    /**
     * handling dropdownDown height
     */
    dropDownHeight?: number;
    onSearchText?: (text: string) => void;
}
type OptionValue$3 = any;
interface Option$5 {
    [key: string]: OptionValue$3;
}

declare const Select: FC<SelectProps$1>;

interface TextareaProps {
    /**
     * Name | name of the textarea field
     */
    name: string;
    /**
     * Label | field label to be displayed
     */
    label: string;
    /**
     * value | textarea field value
     */
    value: string;
    /**
     * variants to set color/style of the textarea field
     */
    variant?: 'default' | 'primary';
    /**
     * error | If true, error message will be displayed
     */
    error?: boolean;
    /**
     * helperText | error, success, warning message to be shown
     */
    helperText?: string;
    /**
     * to disable the textarea field
     */
    disabled?: boolean;
    /**
     * if true, textarea field will be mandatory
     */
    required?: boolean;
    /**
     * placeholder for the textarea field
     */
    placeholder?: string;
    /**
     * classnames to style the textarea field
     */
    className?: string;
    /**
     * onChange, onKeyDown, onBlur, onFocus actions
     */
    onChange?: (event: React.ChangeEvent<HTMLTextAreaElement>) => void;
    onKeyDown?: (event: React.KeyboardEvent<HTMLTextAreaElement>) => void;
    onBlur?: (event: React.FocusEvent<HTMLTextAreaElement>) => void;
    onFocus?: (event: React.FocusEvent<HTMLTextAreaElement>) => void;
    onPaste?: (event: React.ClipboardEvent<HTMLTextAreaElement>) => void;
    /**
     * id to select the textarea field uniquely
     */
    id?: string;
    /**
     * if on, suggestion popup will be displayed
     */
    autoComplete?: 'on' | 'off';
    /**
     * background of the textarea field prop
     */
    /**
     * capacity | Maximum number of characters allowed in the textarea.
     */
    capacity?: number;
    /**
     * rows | Number of visible text lines in the textarea.
     * Used to control the height of the textarea.
     */
    rows?: number;
    /**
     * cols | Number of visible character widths in the textarea.
     * Used to control the width of the textarea.
     */
    cols?: number;
    /**
     * for resizing purpose
     */
    resize?: boolean;
    errorText?: string;
    /**
     * To make text are read only state
     */
    readOnly?: boolean;
    /**
     * To show the capacity of textArea chars.
     */
    displayCapacity?: boolean;
    /**
     * isLabe lRequired for the textArea field without label, showing placeholder
     */
    isLabelRequired?: boolean;
}

declare const Textarea: ({ capacity, name, label, value, variant, error, helperText, disabled, required, placeholder, className, onChange, onBlur, onFocus, onPaste, rows, cols, resize, errorText, readOnly, displayCapacity, isLabelRequired, ...props }: TextareaProps) => react_jsx_runtime.JSX.Element;

interface StatusButtonProps {
    /**
     * Status of the button
     */
    status: 'default' | 'passed' | 'failed' | 'running' | 'skipped' | 'warning' | 'terminated' | 'partially-executed' | 'aborted' | 'not-executed';
    /**
     * Button label (status text)
     */
    label?: string;
    /**
     * Optional click handler
     */
    onClick?: (event: React.MouseEvent<HTMLButtonElement, MouseEvent>) => void;
    /**
     * Button content
     */
    children?: ReactNode;
    /**
     * Button id
     */
    id?: string;
    /**
     * Disabled state
     */
    disabled?: boolean;
    /**
     * Classname for the button
     */
    className?: string;
    /**
     * Additional styles for the button
     */
    style?: React.CSSProperties;
}

declare const StatusButton: ({ status, label, onClick, className, style, disabled, ...props }: StatusButtonProps) => react_jsx_runtime.JSX.Element;

interface OptionClick {
    /**
     * The label displayed for the option.
     * @type {string}
     * @required
     */
    label: string | ReactNode;
    /**
     * The value(s) associated with the option, which can be a single string or an array of strings.
     * @type {Array<string> | string}
     * @required
     */
    value: any;
}
interface OptionType extends OptionClick {
    /**
     * The name of the icon associated with the option.
     * @type {string}
     * @optional
     */
    icon?: string | ReactNode;
    iconColor?: string;
    name?: string | ReactNode;
    /**
     * Indicates whether the option is disabled.
     * @type {boolean}
     * @optional
     */
    disable?: boolean;
    /**
     * To hide the option.
     * @type {boolean}
     * @optional
     */
    hide?: boolean;
    tooltipForOption?: string;
    tooltipPlacementForOption?: 'top' | 'left' | 'right' | 'bottom' | 'top-start' | 'top-end' | 'bottom-start' | 'bottom-end' | undefined;
}
interface MenuOptionProps {
    /**
     * The name of the label displayed next to the icon.
     * @type {string}
     * @optional
     */
    labelName?: string;
    /**
     * The name of the icon to be displayed.
     * @type {string}
     * @required
     */
    iconName: string;
    /**
     * The list of options available in the dropdown.
     * @type {Array<OptionType>}
     * @required
     */
    options: Array<OptionType>;
    /**
     * The title displayed in the tooltip when hovering over the icon.
     * @type {string}
     * @optional
     */
    tooltipTitle?: string;
    /**
     * The placement of the tooltip relative to the icon.
     * @type {'bottom' | 'left' | 'right' | 'top' | 'top-start' | 'top-end' | 'bottom-start' | 'bottom-end'}
     * @optional
     */
    tooltipPlacement?: 'bottom' | 'left' | 'right' | 'top' | 'top-start' | 'top-end' | 'bottom-start' | 'bottom-end';
    /**
     * The placement of the dropdown menu relative to the icon.
     * @type {dropdownPosition}
     * @optional
     */
    dropdownPlacement?: 'top' | 'down' | 'left' | 'right' | 'bottomLeft';
    /**
     * The variant of the menu option, either 'dark' or 'light'.
     * @type {'dark' | 'light'}
     * @default 'light'
     * @optional
     */
    variant?: 'dark' | 'light';
    /**
     * Callback function triggered when the icon is clicked.
     * @type {() => void}
     * @optional
     */
    onClick?: () => void;
    /**
     * Callback function triggered when an option is clicked.
     * @param {OptionClick} option - The option that was clicked.
     * @type {(option: OptionClick) => void}
     * @optional
     */
    onOptionClick?: (option: OptionClick) => void;
    /**
     * The size of the icon button.
     * @type {number}
     * @default 20
     */
    iconButtonSize?: number;
    /**
     * The size of the icon.
     * @type {number}
     * @default 16
     */
    iconSize?: number;
    /**
     * The border radius of the icon button.
     * @type {number}
     * @default 7
     */
    iconButtonBorderRadius?: number;
    /**
     * Providing z-index for the options card.
     * @type {number}
     * @optional
     */
    zIndex?: number;
    /**
     * Variant for backgroung color of options card.
     * @type {string}
     * @optional
     */
    optionCardVariant?: 'primary' | 'default';
    targetRef?: string | React.RefObject<HTMLElement> | null;
    treeRowRef?: React.RefObject<HTMLDivElement | null>;
    isAddResourceButton?: boolean;
    /**
     * to enable or disable the options card.
     * @type {boolean}
     * @optional
     */
    disabled?: boolean;
    /** position of the Menuoption*/
    alignOption?: 'left' | 'right' | 'center';
    displayCard?: boolean;
    didMouseEntered?: () => void;
    tableMenu?: boolean;
}

declare const MenuOption: ({ labelName, iconName, tooltipTitle, tooltipPlacement, options, onClick, onOptionClick, iconButtonSize, iconButtonBorderRadius, iconSize, variant, zIndex, dropdownPlacement, optionCardVariant, targetRef, treeRowRef, isAddResourceButton, disabled, alignOption, displayCard, didMouseEntered, tableMenu, }: MenuOptionProps) => react_jsx_runtime.JSX.Element;

interface DataProps$3 {
    /**
     * data for each row
     */
    [key: string]: any;
}
interface SelectedItemProps$1 {
    /**
     * selected row object | All selected flag
     */
    [key: string]: string | number | boolean;
}
interface TableProps$2 {
    /**
     * Data for table
     */
    data: Array<number | string | DataProps$3>;
    /**
     * Column details for table
     */
    columns: Array<any>;
    /**
     * Header type to have different background color
     */
    headerType: 'default' | 'primary' | 'secondary' | 'tertiary';
    /**
     * 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$1) => 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;
    /**
     *  classNames for the table Header container
     */
    tableHeadClass?: string;
    /**
     *  classNames for the table Row container
     */
    tableBodyRowClass?: string;
    /**
     * custom color for the column text
     */
    headerTextColor?: 'default' | 'primary';
    /**
     * custom color for the row text
     */
    tableDataTextColor?: string;
    /**
     * icon for the table header, for expand or other purposes
     */
    headerIconName?: string;
    /**
     * handle function for the table header icon
     */
    headerIconOnClick?: () => void;
    /**
     * Drag and Drop pass true to enable
     */
    draggable?: boolean;
    /**
     * Drag and Drop indexes
     */
    onDragEnd?: (startIndex: number, endIndex: number) => void | undefined;
    loadMore?: (_direction?: string) => void;
    /**
     * get the status of the accordion which is open or close
     */
    getAccordionStatus?: Function;
    /**
     * content for the accordion
     */
    accordionContent?: ReactNode;
    /**
     * enable editMode by setting state row id
     */
    editMode?: string | null;
    /**
     * The content that to be displayed if editComponent
     */
    editComponent?: ReactNode;
    /**
     * tableRef to get the scroll position & to pass control of table to parent component
     */
    tableRef?: LegacyRef<HTMLTableSectionElement> | React__default.RefObject<HTMLTableSectionElement> | null;
    /**
     * Explicitly handling the checkbox disability for the row.
     */
    isRowCheckBoxDisable?: boolean;
    /**
     * Explicitly handling the disability for the row.
     */
    isRowDisabled?: boolean;
    /**
     * z-index for the table header
     */
    tableHeaderZindex?: number;
    freezeColumns?: number;
    displayCard?: boolean;
}

declare const Table: ({ data, columns, headerType, withCheckbox, onSelect, allSelected, partialSelected, withFixedHeader, borderWithRadius, headerCheckboxDisabled, noDataContent, height, className, tableHeadClass, tableBodyRowClass, headerTextColor, tableDataTextColor, headerIconName, headerIconOnClick, draggable, onDragEnd, loadMore, editMode, editComponent, getAccordionStatus, accordionContent, tableRef, isRowCheckBoxDisable, isRowDisabled, tableHeaderZindex, freezeColumns, }: TableProps$2) => react_jsx_runtime.JSX.Element;

/**
 * Props for the Add Resource Button component.
 *
 * @property {string} [id] - An optional unique identifier for the Add Resource Button.
 * @property {('primary' | 'secondary')} [variant] - Optional button style variant.
 * @property {DirectionalArrow[]} directionalArrow - An array of directional arrows, each specifying the direction and associated menu options. Default values will be provided if not passed.
 * @property {number} [zIndex] - An optional z-index value for positioning, defaults to 99.
 */
interface AddResourceButtonProps {
    id?: string;
    variant?: 'primary' | 'secondary';
    directionalArrow: {
        /**
         * direction option: 'top' | 'right' | 'down'
         */
        direction: string;
        menuOptions: {
            label: string;
            value: string | string[];
            icon?: string;
            disable?: boolean;
            tooltipForOption?: string;
            tooltipPlacementForOption?: 'top' | 'left' | 'right' | 'bottom' | 'top-start' | 'top-end' | 'bottom-start' | 'bottom-end' | undefined;
        }[];
    }[];
    zIndex?: number;
    treeRowRef?: React.RefObject<HTMLDivElement | null>;
    menuOptionZIndex?: number;
    onMenuOptionClick?: (option: {
        label: string | ReactNode;
        value: any;
    }) => void;
    isFromTree?: boolean;
}

declare const AddResourceButton: ({ id, variant, directionalArrow, zIndex, menuOptionZIndex, treeRowRef, onMenuOptionClick, isFromTree, }: AddResourceButtonProps) => react_jsx_runtime.JSX.Element;

type Status = 'passed' | 'failed' | 'warning' | 'skipped' | 'Passed' | 'Failed' | 'Skipped' | 'Warning';
type resultStats = {
    status: Status;
    percentage: number;
    count: number;
};
type DonutChartProps = {
    radius: number;
    lineWidth: number;
    resultStats: resultStats[];
    legendDetailsType: string;
    isLegendDetails: boolean;
    gapAngle?: number;
    totalCount: number;
};

declare const DonutChart: React__default.FC<DonutChartProps>;

interface RadioOption {
    label: string;
    value: string;
}
interface FileDropzoneProps {
    /**
     *  Icon to be displayed in the dropzone.
     **/
    icon?: ReactNode;
    /**
     *  Primary label to be shown in dropzone area
     **/
    primaryLabel?: string;
    /**
     *  Secondary label to be shown
     **/
    secondaryLabel?: string;
    /**
     *  Label to be shown in choose file/input button.
     **/
    buttonLabel?: string;
    /**
     *  . extension needs to be passed to allow the type of file to add or MIME type to be validate MIME type
     **/
    accept: string[];
    /**
     *  To allow multiple selection or drop of files.
     **/
    multiple?: boolean;
    /**
     *  Maximum files to be dropped or selected at once.
     **/
    maxFiles?: number;
    /**
     *  Maximum size of the file in numbers.
     **/
    maxSize?: number;
    /**
     *  Function with state to get the boolean value when the maxFiles is less than dropped files.
     **/
    onMaxFilesError?: () => void;
    /**
     *  To show error message if file size exceeds the max size
     **/
    maxSizeErrorMessage?: string;
    /**
     *  To show error message if file is not of accepted file type
     **/
    invalidFileMessage?: string;
    /**
     *  To show error message if file already exist with same name and type
     **/
    fileExistMessage?: string;
    /**
     *  To validate file type based on MIME type but mandatorily need to pass MIME type in accept props
     **/
    validateMIMEType?: boolean;
    width?: number | string;
    height?: number | string;
    /**
     *  Returns the accepted files in the state
     **/
    getAcceptedFiles?: (files: File[]) => void;
    /**
     *  Returns the rejected files in the state
     **/
    getRejectedFiles?: (files: FileRejection[]) => void;
    /**
     *  If its used in WebService has some other functionality so need to pass boolean value.
     **/
    isWebServiceFileDropZone?: boolean;
    /**
     *  Its the selected radio option as a string.
     **/
    selectedRadioOption?: RadioOption;
    /**
     *  Its the array of radio options in pattern of : {  label: string; value: string; }.
     **/
    radioOptions?: RadioOption[];
    /**
     *  Its the function which updates the selected radio option.
     **/
    handleOptionChange?: (option: RadioOption) => void;
    /**
     *  Its the File Name of File Selected from Local File.
     **/
    setSelectedFile?: (file: File | DynamicObj | null) => void;
    /**
     *  Its the File Name of File Selected from Local File.
     **/
    selectedFile?: File | DynamicObj | null;
    /**
     *  Its the function which updates the Selected file from Local Directory.
     **/
    handleFileChange?: (event: React.ChangeEvent<HTMLInputElement>) => void;
    /**
     *  Its the function which makes the selected File empty state.
     **/
    handleRemoveFile?: () => void;
    /**
     *  When The Api for the response fails need to show error message.
     **/
    isApiResponseError?: boolean;
    /**
     *  If isDisable is true not able to access the FileDropzone
     **/
    isDisable?: boolean;
    /**
     *  Its the boolean value setted when the replace is clicked for TestData radio option .
     **/
    setShowDrawer?: (value: boolean | ((prevState: boolean) => boolean)) => void;
    /**
     *  Its the File Name of File Selected from Local File.
     **/
    setFileContent?: (data: string) => void;
    /**
     *  Its the string value present inside the readable file.
     **/
    fileContent?: string;
    isUploadIcon?: boolean;
    onUploadFile?: () => void;
    showNoFilesUploadedMessage?: boolean;
    noFileUploadedText?: string;
    /**
     *  Its fileInputRef using inside fileDropZone.
     **/
    fileInputRef?: RefObject<HTMLInputElement>;
    handleReplaceFile?: (file?: File | DynamicObj | null) => void;
    /**
     *  To Disable Remove Button.
     **/
    isRemoveDisabled?: boolean;
    /**
     *  To Disable Replace Button.
     **/
    isReplaceDisabled?: boolean;
}
interface FileError {
    message: string;
    code: string;
}
interface FileRejection {
    file: File;
    errors: FileError[];
}
interface DropzoneOptions {
    accept: string[];
    multiple?: boolean;
    maxSize?: number;
    maxFiles?: number | undefined;
    onDrop?: (acceptedFiles: File[], rejectedFiles: FileRejection[], event: React.DragEvent<HTMLElement> | React.ChangeEvent<HTMLInputElement>) => void;
    onMaxFilesError?: () => void;
    maxSizeErrorMessage?: string;
    invalidFileMessage?: string;
    fileExistMessage?: string;
    validateMIMEType?: boolean;
    isApiResponseError?: boolean;
    selectedFile?: File | DynamicObj | null;
    setSelectedFile?: (file: File | DynamicObj | null) => void;
    handleReplaceFile?: (file?: File | DynamicObj | null) => void;
}
interface DropzoneState {
    getRootProps: () => React.HTMLAttributes<HTMLElement>;
    getInputProps: () => React.InputHTMLAttributes<HTMLInputElement>;
    acceptedFiles: File[];
    rejectedFiles: FileRejection[];
    isDragActive: boolean;
    handleRemoveClick: (file: File) => void;
    handleReplaceClick: (file: File) => void;
}
interface DroppableProps {
    icon: React.ReactNode;
    primaryLabel: string;
    secondaryLabel: string;
    buttonLabel: string;
    getRootProps: () => any;
    getInputProps: () => any;
    isDragActive: boolean;
    height: number | string;
    isWebServiceFileDropZone?: boolean;
    selectedRadioOption?: Option;
    radioOptions?: RadioOption[];
    handleOptionChange?: (option: RadioOption) => void;
    selectedFile?: File | DynamicObj | null;
    setSelectedFile?: (file: File | DynamicObj | null) => void;
    handleFileChange?: (event: React.ChangeEvent<HTMLInputElement>) => void;
    handleRemoveFile?: () => void;
    isDisable?: boolean;
    setShowDrawer?: (value: boolean | ((prevState: boolean) => boolean)) => void;
    setFileContent?: (data: string) => void;
    fileContent?: string;
}
interface FilePreviewProps {
    file: File;
    error?: string;
    onRemoveClick: (file: File) => void;
    onReplaceClick: (file: File) => void;
    onUploadFile?: VoidFunction;
    isUploadIcon?: boolean;
    isRemoveDisabled?: boolean;
    isReplaceDisabled?: boolean;
    isError?: boolean;
    isIndependentPreview?: boolean;
}

declare const FileDropzone: React.FC<FileDropzoneProps>;

declare const Dropzone: FC<DroppableProps>;

declare const FilePreview: React.FC<FilePreviewProps>;

type Theme = 'ff-light-theme' | 'ff-dark-theme' | 'ff-grey-theme' | 'ff-blue-theme';
interface ThemeContextType {
    currentTheme: Theme;
    setCurrentTheme: React.Dispatch<React.SetStateAction<Theme>>;
    applyTheme: (newTheme: Theme) => void;
}
interface ThemeProviderProps {
    children?: ReactNode;
    theme?: Theme;
}

declare const ThemeProvider: React__default.FC<ThemeProviderProps>;

interface TypographyProps {
    /**
     * Font Weight
     */
    fontWeight?: 'regular' | 'medium' | 'semi-bold' | 'bold';
    /**
     * Font Size
     */
    fontSize?: number | string;
    /**
     * Line height
     */
    lineHeight?: string;
    /**
     * Color
     */
    color?: string;
    /**
     *  Text alignment
     */
    textAlign?: 'left' | 'right' | 'center' | 'justify';
    /**
     * For JSX elements
     */
    as?: keyof JSX.IntrinsicElements;
    /**
     * htmlFor attribute for element=label,
     */
    htmlFor?: string;
    /**
     * The content to display within the Typography component
     */
    children: React__default.ReactNode;
    /**
     * To add styles in Typography
     */
    className?: string;
    /**
     * To add letter spacing in Typography
     */
    letterSpacing?: string;
    /**
     * To add onClick function
     */
    onClick?: () => void;
    required?: boolean;
    style?: React__default.CSSProperties;
    cursor?: CSSProperties['cursor'];
    onDoubleClick?: () => void;
}

declare const Typography: React__default.FC<TypographyProps>;

interface TruncatedTooltipProps {
    title: string;
    width: number;
}
declare const TruncatedTooltip: React__default.FC<TruncatedTooltipProps>;

declare const useTheme: () => ThemeContextType;

interface FormProps<T extends Form.FieldValues> extends Form.UseFormProps<T> {
    id?: string;
    onSubmit: Form.SubmitHandler<T>;
    children: (methods: ReturnType<typeof Form.useForm<T>> & {
        Form: typeof Form;
    }) => React__default.ReactNode;
}
declare const ForwardedForms: <T extends Form.FieldValues>(props: FormProps<T> & {
    ref?: React__default.Ref<any>;
}) => JSX.Element;

interface Option$4 {
    label: string | ReactNode;
    value: string;
}
interface InputWithDropdownProps {
    /**
     * Name | name of the input field
     */
    name: string;
    /**
     * Label | field label to be displayed
     */
    label?: string;
    /**
     * value | input field value
     */
    value?: string | number;
    type?: 'text' | 'password' | 'number' | 'email' | 'url' | 'time';
    /**
     * variants to set color/style of the input field
     */
    variant?: 'default' | 'primary';
    /**
     * error | If true, error message will be displayed
     */
    error?: boolean;
    /**
     * helperText | error, success, warning message to be shown
     */
    helperText?: string;
    /**
     * 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;
    /**
     * Options for the select dropdown
     */
    optionsList: Option$4[];
    /**
     * Selected option for the select dropdown
     */
    selectedOption?: Option$4;
    /**
     * onChange handler for input changes
     */
    onInputChangeHandler?: (event: React.ChangeEvent<HTMLInputElement>) => void;
    /**
     * onChange handler for dropdown changes
     */
    onDropdownChangeHandler?: (option: any) => void;
    /**
     * onInputBlurHandler action for input field
     */
    onInputBlurHandler?: (event: React.FocusEvent<HTMLInputElement>) => void;
    onFocus?: (event: React.FocusEvent<HTMLInputElement>) => void;
    onClick?: (event: React.MouseEvent<HTMLInputElement>) => void;
    onKeyUp?: (event: React.KeyboardEvent<HTMLInputElement>) => void;
    /**
     * id to select the input field uniquely
     */
    id?: string;
    /**
     * if on, suggestion popup will be displayed
     */
    autoComplete?: 'on' | 'off';
    /**
     * minimum and maximum values for the number type input field
     */
    minValue?: number;
    maxValue?: number;
    /**
     * background of the input field prop
     */
    isBackgroundTransparent?: boolean;
    /**
     * optionsRequired:false prop removes options from dropdown & shows static label only
     */
    optionsRequired?: boolean;
    dropdownPosition?: 'left' | 'right';
    leftDropDownPositionZindex?: number;
    rightDropDownPositionZindex?: number;
    onKeyDown?: (event: React.KeyboardEvent<HTMLInputElement>) => void;
    /**
     * pattern for input component
     */
    pattern?: string;
    inputMode?: 'numeric';
    /**
     * props for disableSelectHover
     */
    disableSelectHover?: boolean;
    inputRefWithDropdown?: RefObject<HTMLInputElement>;
}

declare const InputWithDropdown: React$1.ForwardRefExoticComponent<InputWithDropdownProps & React$1.RefAttributes<HTMLInputElement>>;

/**
 * Props for the RadioButton component.
 */
interface RadioButtonProps {
    /**
     * The display label for the radio button.
     * Optional.
     */
    label?: string | ReactElement;
    /**
     * The name attribute for the radio button, used for grouping.
     */
    name: string;
    /**
     * The unique value of the radio button.
     * Optional.
     */
    value?: string;
    /**
     * Indicates whether the radio button is checked.
     * Optional.
     */
    checked?: boolean;
    /**
     * Callback function that is called when the radio button's value changes.
     * Receives the change event as an argument.
     * Optional.
     */
    onChange?: (event: React.ChangeEvent<HTMLInputElement>) => void;
    /**
     * Indicates whether the radio button is disabled.
     * Optional.
     */
    disabled?: boolean;
    /**
     * Indicates whether the radio button show the tooltip.
     * Optional.
     */
    showTooltip?: boolean;
    /**
     * The content of the tooltip.
     * Optional.
     */
    tooltipChildren?: React.ReactNode;
    /**
     * The content of the tooltip.
     * Optional.
     */
    tooltipTitle?: React.ReactNode;
    /**
     * Additional CSS classes to be applied to the radio button.
     * Optional.
     */
    tooltipPosition?: 'top' | 'bottom' | 'left' | 'right';
    onBlur?: () => void;
}

declare const RadioButton: React__default.FC<RadioButtonProps>;

declare const RadioGroup: React__default.FC<RadioGroupProps>;

interface ModalDimensions {
    width?: number;
    height?: number;
    borderRadius?: number;
    zIndex?: number;
    boxShadow?: string;
    left?: number;
    top?: number;
    padding?: number;
    right?: number;
}
type ModalPosition = 'bottom' | 'right' | 'top' | 'left';
interface MiniEditModalProps {
    /**
     * A reference to the button element that triggers the modal.
     */
    anchorRef?: RefObject<HTMLButtonElement> | string;
    id?: string | number;
    /**
     * Optional properties for configuring the modal header.
     */
    headerProps?: ReactNode;
    /**
     * The main content to be displayed inside the modal
     */
    childContent: ReactNode;
    /**
     * Props for the cancel button inside the modal
     */
    cancelButtonProps?: any;
    /**
     * Props for the proceed button inside the modal.
     */
    proceedButtonProps?: any;
    /**
     * Optional content for the footer of the modal.
     */
    footerContent?: ReactNode;
    /**
     * Determines if the modal should be wrapped inside a container element.
     */
    isWrapped?: boolean;
    /**
     * Determines if the modal should have an animation when displayed.
     */
    isAnimated?: boolean;
    /**
     * Specifies if the modal should behave as a popover with an arrow.
     */
    isPopOver?: boolean;
    /**
     * Specifies if the modal should behave as a popover with an arrow.
     */
    isIconModel?: boolean;
    /**
     * Sets the position of the modal relative to its anchor.
     * bottom: The modal appears below the anchor.
     * right: The modal appears to the right of the anchor.
     */
    modalPosition?: ModalPosition;
    /**
     * Adds a top-left aligned arrow to the modal when its position is set to `'right'`.
     */
    leftTopArrow?: boolean;
    /**
     * A reference to an additional anchor element for positioning the modal.
     */
    firstAnchorRef?: RefObject<HTMLButtonElement>;
    /**
     * A numeric value representing the left position of the anchor element, used to calculate the modal's left position.
     */
    anchorRefLeftNum?: number;
    /**
     * Optional properties for configuring the modal's dimensions.
     * width: The width of the modal.
     * height: The height of the modal.
     */
    modalProperties?: ModalDimensions;
    /**distance for the wrapper model from align alignments */
    anchorLeftDistanceForWrapper?: number;
    /**extra top space added from anchor */
    extraTopSpace?: {
        wrappedModal?: number;
        normalModal?: number;
    };
    /**extra right space added from anchor */
    extraRightSpace?: {
        leftTopArrow?: number;
        middleLeftArrow?: number;
    };
    /**extra left space added from anchor */
    extraLeftSpace?: {
        normal?: number;
        rightAlignModal?: number;
    };
    wrapperProperties?: {
        height?: number;
        top?: number;
        width?: number;
        zIndex?: number;
        boxShadow?: string;
    };
    arrowZIndex?: number;
    arrowProperties?: {
        right?: number;
        left?: number;
        top?: number;
        size?: number;
    };
    overlay?: {
        isOverlay?: boolean;
        zIndexOverlay?: number;
        backgroundColorOverlay?: string;
    };
    outSideClick?: any;
    ignoreRefs?: Array<React.RefObject<HTMLElement>>;
}

declare const MiniModal: React$1.ForwardRefExoticComponent<MiniEditModalProps & React$1.RefAttributes<HTMLDivElement>>;

interface OverviewModalProps {
    isOpen: boolean;
    isMaximized: boolean;
    width?: string;
    height?: string;
    header?: React.ReactNode;
    children?: React.ReactNode;
    icons?: React.ReactNode;
    downloadFileIcon?: boolean;
    onClose: () => void;
    onMaximizeToggle?: () => void;
    showHeader: boolean;
    top?: string;
    overlay?: boolean;
    downloadHandler: () => void;
    zIndex?: number;
    customStyle?: React.CSSProperties;
    multiData?: Array<{
        machineName: string;
        scriptName: string;
        icon: string;
        src: string;
        alt: string;
        runId: string;
        currentScripts: number;
        totalScripts: number;
    }>;
    setSelectedVideo?: (video: {
        currentVideoData: {
            machineName: string;
            scriptName: string;
            icon: string;
            src: string;
            alt: string;
            runId: string;
            currentScripts: number;
            totalScripts: number;
            clickedAt: number;
        };
        allVideoData: Array<{
            machineName: string;
            scriptName: string;
            icon: string;
            src: string;
            alt: string;
            runId: string;
            currentScripts: number;
            totalScripts: number;
        }>;
    }) => void;
}

declare const OverviewModal: React__default.FC<OverviewModalProps>;

type TreeNodeProps = {
    executionId?: string;
    runId?: string;
    clientId?: string;
    status?: string;
    resultPercentage?: Record<string, number>;
    reRun?: boolean;
    reRunFailed?: boolean;
    results?: boolean;
    reports?: boolean;
    createdBy?: string;
    modifiedBy?: string;
    createdByUname?: string;
    modifiedByUname?: string;
    createdOn?: string;
    modifiedOn?: string;
    state?: string;
    path?: string;
    searchKey?: string;
    key: string;
    name?: string;
    projectId?: string;
    hierarchy: number;
    executionOrder?: number;
    conditionCount?: number;
    subContainerCount?: number;
    resourceCount?: number;
    totalSubContainerCount?: number;
    totalResourceCount?: number;
    totalProjectElementCount?: number;
    totalSharedElementCount?: number;
    container?: boolean;
    localDelete?: boolean;
    defaultEntity?: boolean;
    lastResource?: boolean;
    lastChild?: boolean;
    platform?: string;
    parentId?: string;
    parentName?: string;
    checked?: boolean | 'partial';
    expanded?: boolean;
    expandable?: boolean;
    sourceId?: string;
    isNewNode?: boolean;
    entityType?: string;
    lastDefaultEntity?: string;
    type?: string;
    label?: string;
    isShared?: boolean | string;
    isRecorded?: string;
    originalId?: string;
    locatorsCount?: number;
    version?: string;
    hide?: boolean;
    folder?: boolean;
    selectedStatus?: 'completely' | 'partially' | 'none';
    isDelete?: boolean;
    reviewerId?: string;
    reviewerName?: string;
    localCopyId?: string;
    localAutomationId?: string;
    localManualId?: string;
    cascaded?: string;
    automationId?: string;
    manualId?: string;
    unselectable?: boolean;
    description?: string;
    desc?: string;
    expandedAll?: boolean;
    hideResources?: boolean;
    hidePreOrPost?: boolean;
    isScript?: boolean;
    stepId?: string;
    conditionId?: string;
    machInstanceId?: string;
    duration?: string;
    headless?: boolean;
};

interface NewNode$1 {
    sourceId?: string;
    payloadSourceId?: string;
    action?: 'addAbove' | 'addBelow' | 'addInside';
    type?: 'input' | 'inputWithDropdown';
    options?: [];
    selectedOption?: string;
    value?: string;
    error?: string;
    label?: string;
    confirmIconTooltip?: string;
    cancelIconTooltip?: string;
}
declare type JSX$2 = ReactNode | JSX$2.Element[] | string | null;
type RootNode$1 = {
    node: any;
    select: 'radio' | 'checkbox' | 'none';
    cell?: (row: any) => JSX$2;
    actions?: (row: any, treeRowRef?: React.RefObject<HTMLDivElement | null>) => JSX$2;
};
interface Column$1 {
    name: string | JSX$2;
    accessor: string;
    width: string;
    isClickable?: boolean;
    cell?: (row: any) => JSX$2;
    actions?: (row: any, treeRowRef?: React.RefObject<HTMLDivElement | null>) => JSX$2;
    isTree?: boolean;
    defaultValue?: string;
    defaultActions?: () => JSX$2;
}
interface TreeTableProps$1 {
    treeData: any;
    columnsData: Column$1[];
    selected?: string[];
    select?: 'radio' | 'checkbox' | 'none';
    onChange?: (e: any, node: string[] | any) => void;
    onClick?: (e: React.MouseEvent<HTMLDivElement>, row: TreeNodeProps) => void;
    onExpand?: (node: TreeNodeProps) => void;
    loadMore?: (_direction?: string) => void;
    tableBorder?: string;
    height?: number | string;
    newNode?: NewNode$1;
    onAddConfirm?: (_name: string, _type?: Option$3) => void;
    onAddCancel?: () => void;
    loading?: boolean;
    rootNode?: RootNode$1;
    getContentLength?: number;
    handleEditFieldError?: (inputText: string) => string;
    pagination?: boolean;
    selectedNode?: string;
    tableHeaderBgColor?: string;
    hideOnDisable?: boolean;
    freezeColumns?: number;
    scriptLengthTruncate?: number;
    addModuleInputWidth?: number;
    addModuleSelectWidth?: number;
    onScroll?: () => void;
    disableEditLabelConfirmIcon?: boolean;
    transparentHeader?: boolean;
}
type OptionValue$2 = any;
interface Option$3 {
    [key: string]: OptionValue$2;
}

declare const TreeTable: React__default.ForwardRefExoticComponent<TreeTableProps$1 & React__default.RefAttributes<HTMLDivElement>>;

interface TabsProps$1 {
    /**
     * An array of tab objects containing label, component, and optional disabled status.
     */
    tabsData: {
        id: string;
        label: string;
        icon?: string;
        component?: JSX.Element;
        disabled?: boolean;
        count?: number | string;
        status?: 'success' | 'error' | 'transparent';
    }[];
    /**
     * Defines the styling variant of the tabs.
     */
    variant?: 'default' | 'capsule';
    /**
     * activeTabId : The ID of the currently active tab.
     */
    activeTabId: string;
    /**
     * onTabClick : function updates the active tab state when a user interacts with the tabs,
     */
    onTabClick: (id: string) => void;
    /**
     * noBorder:true , removes the outer border from tabs
     */
    noBorder?: boolean;
    noPadding?: boolean;
    /**
     * titleSize is to accpect dynamic font size
     */
    titleSize?: number | string;
    /**
     * to add borderBottom line
     */
    isBorderBottomLine?: boolean;
    /**
     *  to change background on hover
     */
    isHoverBackground?: boolean;
    /**
     *  to add border-radius to tabs
     */
    isBorderRadius?: boolean;
    /**
     * tabFlexSpacing : Defines the flex spacing for the tab row.
     */
    tabFlexSpacing?: 'space-between' | 'space-around' | 'flex-start' | 'flex-end' | 'center';
}

declare const Tabs: ({ variant, tabsData, activeTabId, onTabClick, noBorder, noPadding, titleSize, isBorderBottomLine, isHoverBackground, isBorderRadius, tabFlexSpacing, }: TabsProps$1) => react_jsx_runtime.JSX.Element;

/**
 * Represents a single tab in the BrowserTabs component.
 */
interface BrowserTab {
    /**
     * Unique identifier for the tab.
     */
    id: string;
    /**
     * Label text displayed on the tab.
     */
    label: string;
    /**
     * Optional component to be rendered when the tab is active.
     */
    component?: JSX.Element;
    /**
     * Name of the tab icon.
     */
    tabIcon?: string;
    /**
     * Optional URL for a dynamic icon.
     */
    tabIconSrc?: string;
}
/**
 * Props for the BrowserTabs component.
 */
interface BrowserTabsProps {
    /**
     * An array of tab objects containing label, icon, and an optional component.
     */
    tabsData: BrowserTab[];
    /**
     * The ID of the currently active tab.
     */
    activeTabId: string;
    /**
     * Function to update the active tab state when a user clicks on a tab.
     * @param id - The unique identifier of the clicked tab.
     */
    onTabClick: (id: string) => void;
    /**
     * Function to add a new tab.
     */
    onTabAdd?: () => void;
    /**
     * Function to close a specific tab.
     * @param index - The index of the tab to be closed.
     */
    onTabClose?: (id: string) => void;
    /**
     * Minimum width for each tab (in pixels).
     */
    minTabWidth?: number;
    /**
     * Maximum width for each tab (in pixels).
     */
    maxTabWidth?: number;
    /**
     * Show the close button only for the active tab.
     */
    showCloseOnActive?: boolean;
    /**
     * Custom CSS class name to override default styles.
     */
    className?: string;
}

declare const BrowserTabs: ({ tabsData, activeTabId, onTabClick, onTabClose, onTabAdd, maxTabWidth, showCloseOnActive, }: BrowserTabsProps) => react_jsx_runtime.JSX.Element;

interface HighlightTextProps {
    text?: string;
    highlight?: String;
    onlyExactMatch?: boolean;
}

declare const HighlightText: React.FC<HighlightTextProps>;

interface CheckboxProps {
    /**
     * Unique ID for the checkbox input
     */
    id?: string;
    /**
     * Name attribute for the checkbox input
     */
    name?: string;
    /**
     * Optional side label
     */
    label?: string | ReactNode;
    /**
     * Optional disable attribute
     */
    disabled?: boolean;
    /**
     * Optional checked attribute to prefill
     */
    checked?: boolean;
    /**
     * Optional onChange function
     */
    onChange?: (event: React.ChangeEvent<HTMLInputElement>) => void;
    /**
     * For partially checked checkbox
     */
    partial?: boolean;
    /**
     * For variant color
     */
    variant?: 'passed' | 'failed' | 'warning' | 'skipped' | 'flaky';
    /**
     * For default hover
     */
    isDefaultHover?: boolean;
    /**
     * For label font size
     */
    labelFontSize?: number;
}

declare const Checkbox: React__default.FC<CheckboxProps>;

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
     */
    disabled?: boolean;
    width?: number;
    value: string;
    isExpand: boolean;
    onClose: () => void;
    onExpand: (isExpand: boolean) => void;
    showClose?: boolean;
    helperText?: string;
    showToaster?: boolean;
    minLength?: number;
    isAISearch?: boolean;
    isAISearchClicked?: boolean;
    handleActiveAiSearch?: () => void;
    isClear?: boolean;
    handleIsClear?: () => void;
    style?: React.CSSProperties;
}

declare const Search: ({ placeholder, onSearch, disabled, width, value, isExpand, onClose, onExpand, showClose, helperText, showToaster, minLength, isAISearch, isAISearchClicked, handleActiveAiSearch, isClear, handleIsClear, style, }: SearchProps) => react_jsx_runtime.JSX.Element;

interface DatePickerProps {
    /**
     * The minimum selectable date.
     */
    minDate?: DateValue;
    /**
     * The maximum selectable date.
     */
    maxDate?: DateValue;
    /**
     * Selected date value.
     */
    value?: DateValue;
    /**
     * Function to handle date selection.
     */
    onChange: (value: DateValue, formatted?: string) => void;
    /**
     * Placeholder text for the input field.
     */
    placeholder?: string;
    /**
     * Disables the date picker.
     */
    disabled?: boolean;
    /**
     * Format for displaying the selected date. Default is 'EEEE, dd MMM yyyy'.
     */
    dateFormat?: string;
    /**
     * Format for displaying the selected time. Default is 'hh:mm a'.
     */
    timeFormat?: string;
    /**
     * Timezone for the date picker.
     */
    timezone?: string;
    /**
     * Custom width for the calendar. This will override the default width of the calendar.
     */
    calendarWidth?: number;
    /**
     * When true, displays the input field error.
     */
    error?: boolean;
    /**
     * Helper text to display below the input field, used for error messages or instructions.
     */
    helperText?: string | undefined;
    /**
     * Select only date .
     */
    dateOnly?: boolean;
    className?: string;
    zIndex?: number;
    /**
     * Default: false, if true, displayed with border radius and color required for the filter date picker.
     */
    isFilterDatePicker?: boolean;
    /**
     * The selected date don't want to be deselected .
     */
    isSelectableDate?: boolean;
    /**
     * Function to handle onBlur for datepicker.
     */
    onBlur?: (date: DateValue) => void;
    /**
     * Default:False,if true, the date picker will not apply any date formatting.
     */
    withOutDateFormat?: boolean;
}
type DateValue = Date | undefined;

declare const CustomDatePicker: React__default.ForwardRefExoticComponent<DatePickerProps & React__default.RefAttributes<HTMLDivElement>>;

interface StateDropdownProps {
    value: string;
    isReviewer: boolean;
    isApprovePage: boolean;
    handleDropdownOptionsClick: (option: Option$5) => void;
    disabled: boolean;
    isOnlyReviewer: boolean;
    handleStateValueClick: () => void;
    showBorder?: boolean;
    zIndex?: number;
}

declare const StateDropdown: ({ value, isReviewer, isApprovePage, handleStateValueClick, handleDropdownOptionsClick, disabled, isOnlyReviewer, showBorder, zIndex, }: StateDropdownProps) => react_jsx_runtime.JSX.Element;

interface IconButtonProps {
    label: string;
    iconName?: string;
    onClick?: (event: React.MouseEvent<HTMLButtonElement, MouseEvent>) => void;
    ref?: React.Ref<HTMLButtonElement>;
    iconHide?: boolean;
    isDisable?: boolean;
    variant?: 'default' | 'primary';
}

declare const IconButton: React$1.ForwardRefExoticComponent<Omit<IconButtonProps, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;

interface ModalProps {
    isOpen: boolean;
    onClose: () => void;
    /*** label value for aria-label  */
    contentLabel?: string;
    /*** default header will be provided with title and close icon. */
    isHeaderDisplayed: boolean;
    /*** Title to be displayed in the header when defaultHeader is true*/
    headerTitle?: string;
    /*** 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;
    headerContent?: string | ReactNode;
    footerContent?: ReactNode;
    /***Content to be displayed inside the modal */
    children: ReactNode;
    isFooterDisplayed: boolean;
    customWidth?: string;
    customHeight?: string;
    zIndex?: number;
    boxShadow?: string;
    border?: string;
    background?: string;
    ref?: Ref<HTMLDivElement>;
    style?: React.CSSProperties;
}

declare const Modal: React$1.ForwardRefExoticComponent<Omit<ModalProps, "ref"> & React$1.RefAttributes<HTMLDivElement>>;

declare const DragAndDrop: {
    DNDCore: typeof DNDCore;
    DNDSortable: typeof DNDSortable;
    DNDUtilities: typeof DNDUtilities;
    DNDModifiers: typeof DNDModifiers;
};

interface VariableInputProps {
    /**
     * Name | name of the input field
     */
    name: string;
    /**
     * Label | field label to be displayed
     */
    label: string;
    /**
     * value | input field value
     */
    value: string | null;
    /**
     * type to set color/style of the input field
     */
    type: 'text' | 'password' | 'number' | 'email' | 'url' | 'time';
    /**
     * error | If true, error message will be displayed
     */
    error?: 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, onKeyDown, onBlur, onFocus actions
     */
    onChange?: (value: string) => void | undefined;
    onKeyDown?: (event: React.KeyboardEvent<HTMLInputElement>) => void;
    onBlur?: (event: React.FocusEvent<HTMLInputElement>) => void;
    onFocus?: (event: React.FocusEvent<HTMLInputElement>) => void;
    /**
     * id to select the input field uniquely
     */
    id?: string;
    /**
     * list of variables
     */
    list?: string[];
}

declare const VariableInput: ({ type, name, label, disabled, required, placeholder, value, error, className, onChange, onKeyDown, onBlur, onFocus, list, ...props }: VariableInputProps) => react_jsx_runtime.JSX.Element;

interface optionsType$1 {
    label: string;
    value: string;
    iconName: string;
    platform?: string;
    appType?: string;
}
interface AllProjectsDropdownProps {
    options: optionsType$1[];
    onMenuClick?: () => void;
    onClick: (option: optionsType$1) => void;
    selectedOption: optionsType$1;
    selected?: boolean;
    placeholder?: string;
    disabled?: boolean;
}

declare const AllProjectsDropdown: ({ onClick, onMenuClick, options, selectedOption, selected, placeholder, disabled, }: AllProjectsDropdownProps) => react_jsx_runtime.JSX.Element;

interface PieChartProps {
    radius: number;
    data: Array<{
        label: string;
        value: number | string;
    }>;
    colors: string[];
    chartBorder: boolean;
}

declare const PieChart: React__default.FC<PieChartProps>;

interface AppHeaderProps {
    scriptId?: string | undefined | null;
    width?: string;
    borderRadius?: string;
    logo: ReactNode;
    leftContent?: ReactNode;
    rightContent?: ReactNode;
    projectsList?: optionsType$1[];
    appHeaderMenuItems: appHeaderMenuItemProps[];
    appHeaderHiddenMenuItems?: appHeaderMenuItemProps[];
    selectedMenu: string;
    selectedSubMenu?: string;
    selectedQuickMenu?: string;
    selectedProject?: optionsType$1;
    onMenuClick?: (text: any) => void;
    onSubMenuClick?: (text: any) => void;
    onQuickMenuClick?: (text: any) => void;
    onProjectMenuClick?: (text: any) => void;
    onProjectDropdownLabelClick?: () => void;
    onMoreMenuOptionClick?: (text: any, callback: () => void) => void;
    disabled?: boolean;
    isClient?: boolean;
    hideNavbar?: boolean;
    profileContent?: ReactNode;
}
interface appHeaderMenuItemProps {
    iconName?: string;
    label: string;
    path?: string;
    disable?: boolean;
    disableText?: string;
    hide?: boolean;
    access?: string;
    isReviewer?: boolean;
    entityPendingCounts?: {
        [key: string]: number;
    };
    subMenuItems?: appHeaderSubMenuItemProps[];
}
interface appHeaderSubMenuItemProps {
    label: string;
    path?: string;
    disable?: boolean;
    disableText?: string;
    hide?: boolean;
    quickMenuItems?: appHeaderQuickMenuItemProps[];
    hiddenMenuItems?: appHeaderHiddenMenuItemProps[];
}
interface appHeaderQuickMenuItemProps {
    label: string;
    path: string;
    iconName: string;
    disable?: boolean;
    disableText?: string;
    hide?: boolean;
}
interface appHeaderHiddenMenuItemProps {
    label: string;
    value?: string | string[];
    icon?: string;
    disable?: boolean;
    disableText?: string;
    hide?: boolean;
    path?: string;
    iconName?: string;
}

declare const AppHeader: React__default.FC<AppHeaderProps>;

interface PaperProps {
    /**
     * The content of the component.
     */
    children?: React.ReactNode;
    /**
     * Override or extend the styles applied to the component.
     */
    className?: string;
    /**
     * If `true`, rounded corners are Enabled.
     * @default false
     */
    rounded?: boolean;
}

declare const Paper: ({ children, className, rounded }: PaperProps) => react_jsx_runtime.JSX.Element;

type ChartItem = {
    key: string;
    value: string | number;
    color?: string;
    percentage?: string | number;
    version?: number[] | string[];
    versionColor?: string[];
    osIcon?: string;
};
type LegendType$1 = 'numberLegend' | 'pillLegend' | 'memoryLegend' | 'tableLegend';
type DashboardDonutChartProps = {
    radius: number;
    lineWidth: number;
    statusValues: ChartItem[];
    legendDetailsType: string;
    isLegendDetails: boolean;
    gapAngle?: number;
    legendType: LegendType$1;
    apiDataLabel?: string | number;
    showOnlyLabel?: boolean;
    unit?: string;
    showUnit?: boolean;
    labelFontSize?: number;
    subLabelFontSize?: number;
    legendPosition?: 'bottom' | 'right' | 'left';
    chartGap?: number;
    legendGap?: number;
    tableWidth?: number;
    tableHeight?: number;
    legendValueFontSize?: number;
    legendKeyFontSize?: number;
    legendWithVersionFontSize?: number;
    versionErrorText?: string;
    labelYoffSet?: number;
    subLabelYoffSet?: number;
    capsuleStyle?: {};
    legendTruncate?: number;
    isLegendToolTip?: boolean;
    containerHeight?: number | string;
    onSelectedStatus?: (_value: string) => void;
    selectedStatusKey?: string;
    setSelectedStatusKey?: (_selectedStatusKey: string) => void;
    isOnClick?: boolean;
    zIndex?: number;
};

declare const DashboardDonutChart: React__default.FC<DashboardDonutChartProps>;

type FixedReCAPTCHA = React.ComponentType<{
    sitekey: string;
    onChange: (token: string | null) => void;
    className?: string;
    theme?: 'light' | 'dark';
    size?: 'compact' | 'normal' | 'invisible';
    tabindex?: number;
    badge?: 'bottomright' | 'bottomleft' | 'inline';
}>;
interface RecaptchaProps extends Omit<ComponentProps<FixedReCAPTCHA>, 'onChange'> {
    /**
     * Callback function that receives the verification token
     */
    onVerify: (token: string | null) => void;
    /**
     * Optional CSS class name
     */
    className?: string;
    /**
     * Optional error message to display
     */
    error?: string | null;
    /**
     * reCAPTCHA site key
     */
    sitekey: string;
}

declare const Recaptcha: React__default.ForwardRefExoticComponent<RecaptchaProps & React__default.RefAttributes<ReCAPTCHA>>;

interface NlpChip {
    name: string;
    isSelected: boolean;
}
interface SelectProps {
    label?: string;
    rightIcon?: string;
    leftIcon?: string;
    showLabel?: boolean;
    onHelpIconClick?: () => void;
    webServiceClick?: () => void;
    aiIconClick?: () => void;
    rightIconColor: string;
    optionsList: any[];
    selectedOption?: NlpRenderOption;
    containerWidth?: string | number;
    onChange: (option: React.ChangeEvent<HTMLInputElement>) => void;
    errorMsg?: string;
    className?: string;
    optionZIndex?: number;
    disabled?: boolean;
    borderRadius?: boolean;
    showBorder?: boolean;
    required?: boolean;
    value: string;
    onSelect: (e: any) => void;
    chipOptionList?: NlpChip[];
    selectedChips?: any;
    loadMoreOptions?: () => void;
    isWebservice?: boolean;
    closeInputOnOutsideClick?: () => void;
    tooltipText?: string;
    ChipsAccordionWidth?: string;
}
interface NlpRenderOption {
    displayName: string | ReactNode;
    projectId: string;
    nlpType: string;
    platform: string;
    disabled?: boolean;
    videoSrc?: string;
    nlpName?: string;
    name?: string;
}

declare const NlpInput: ({ label, leftIcon, rightIcon, rightIconColor, showLabel, onHelpIconClick, aiIconClick, webServiceClick, containerWidth, optionsList, selectedOption, onChange, errorMsg, className, optionZIndex, disabled, borderRadius, showBorder, required, value, onSelect, chipOptionList, selectedChips, loadMoreOptions, isWebservice, closeInputOnOutsideClick, tooltipText, ChipsAccordionWidth, }: SelectProps) => react_jsx_runtime.JSX.Element;

interface IconRadioItem {
    /**
     * The unique name for the icon, used to load the corresponding icon.
     */
    iconName: string;
    /**
     * The display label for the icon. This can be used for accessibility purposes.
     */
    iconLabel: string;
    /**
     * Flag to determine if the icon option is disabled.
     */
    disabled?: boolean;
    /**
     * Message to display when the option is disabled.
     */
    disableMessage?: string;
}
interface IconRadioGroupProps {
    /**
     * Array of icon items that make up the radio button group.
     */
    items: IconRadioItem[];
    /**
     * Callback function called when a button/icon is clicked.
     * It returns the selected item.
     */
    onButtonClick: (selectedItem: IconRadioItem) => void;
    /**
     * The currently selected icon value
     */
    selectedValue?: string | null;
    /**
     * Callback function to notify parent of selection change.
     */
    onChange?: (selected: string | null) => void;
    /**
     * Optional className for custom styling
     */
    className?: string;
}

declare const IconRadioGroup: React__default.FC<IconRadioGroupProps>;

interface MachineType {
    type: string;
    label: string;
    version?: string;
}
interface MachineInputFieldProps {
    width?: string;
    options: MachineType[];
    runCount: number;
    className?: string;
    contentReverse?: boolean;
    onClick?: () => void;
    modalId?: string;
    trucatedLable?: boolean;
    scriptType?: string;
    readOnly?: boolean;
}

declare const MachineInputField: {
    ({ width, options, runCount, className, contentReverse, onClick, modalId, scriptType, readOnly, }: MachineInputFieldProps): react_jsx_runtime.JSX.Element;
    displayName: string;
};

type EnvironmentVariableMaps = {
    testDataSetMap: Record<string, string>;
    globalVariableMap: Record<string, string>;
    projectVariableMap: Record<string, string>;
};
interface SequentialConnectingBranchProps {
    machineInstances: ExecutionContext[] | {}[];
    machineColumnWidth?: number;
    machineColumnCount?: number;
    selectedMachine?: Option$5;
    machineOptionsList?: Option$5[];
    onHandleSelect?: (option: Option$5) => void;
    onAddBrowserInstance?: (modalId: string) => void;
    onUpdateAddBrowserInstance?: (modalId: string, machineInstance: ExecutionContext) => void;
    onDeleteBrowserInstance?: (id: string, runCount: number) => void;
    onAddRunBrowserInstance?: (machineInstanceId: string) => void;
    onDeleteMachineInstance?: () => void;
    onUpdateDataSetList?: (id: string, dataSetObject?: dataSetValues, isInstance?: boolean, noOfRuns?: number, machineInstanceId?: string) => void;
    dataSetValues?: dataSetValues;
    addInstanceLabel?: string;
    scriptType?: string;
    projectType?: string;
    readOnly?: boolean;
    integrationInstance?: IntegrationInstance;
    zIndex?: number;
    placeholder?: string;
    maxRunCount?: number;
    environmentVariableMaps?: EnvironmentVariableMaps;
    isRequired?: boolean;
}
interface IntegrationInstance {
    usename: string;
    accessKey: string;
}
interface MachineInfo {
    osName: string;
    osVersion: string;
    hostName: string;
    iconName: string;
}
interface DeviceInfo {
    name: string;
    platform: string;
    version?: string;
}
interface ExecutionContext {
    machineInstanceId: string;
    clientId: string;
    numberOfRuns: number;
    runCount: number;
    executionEnv?: 'Local' | string;
    browserName?: 'Local' | 'mac' | 'android' | 'Google Chrome';
    browserVersion: string;
    systemUrl: string;
    machineInfo: MachineInfo;
    deviceInfo: DeviceInfo[];
    headless: boolean;
    peVariableSetId: string;
    testDataSetName: string;
    globalVariableSetName: string;
    peVariableSetName: string;
    globalVariableSetId: string;
    testDataSetId: string;
    integrationInstance: IntegrationInstance;
}
interface dataSetValues {
    peVariableSetId: string;
    globalVariableSetId: string;
    testDataSetId: string;
    testDataSetName: string;
    globalVariableSetName: string;
    peVariableSetName: string;
}

declare const SequentialConnectingBranch: FC<SequentialConnectingBranchProps>;

interface AttachmentUploaderProps {
    label: string;
    selectedFiles: File[];
    onFilesChange: (files: File[], selectedFile?: File[], changeType?: 'ADD' | 'DELETE') => void;
    disabled?: boolean;
    maxFileSizeMB?: number;
    maxFiles?: number;
    buttonLabel?: string;
    showSelectedFiles?: boolean;
    buttonVariant?: 'primary' | 'secondary' | 'tertiary' | 'delete' | 'warning';
    deleteButton: boolean;
    addAttachmentButton: boolean;
    accept?: string[];
    onFileListClick?: (event: React.MouseEvent<HTMLElement, MouseEvent>) => void;
    types?: string[];
    iconName?: string;
    buttonDisplayType?: 'attachment' | 'icon';
    isInfoIconRequired?: boolean;
    multiple?: boolean;
    attachmentInfoTooltip?: string;
    selectedFileMessage?: string;
    required?: boolean;
    errorMessage?: string;
    onBlur?: (event?: React.FocusEvent<HTMLInputElement>) => void;
    truncateMaxLimit?: number;
}

declare const AttachmentButton: React__default.FC<AttachmentUploaderProps>;

type AcceptedType = string | (() => void) | Record<string, unknown> | unknown[];

declare const Toastify: () => react_jsx_runtime.JSX.Element;

declare const toast: {
    success: (arg1: AcceptedType, arg2?: AcceptedType) => void;
    error: (arg1: AcceptedType, arg2?: AcceptedType) => void;
    warning: (arg1: AcceptedType, arg2?: AcceptedType) => void;
    info: (arg1: AcceptedType, arg2?: AcceptedType) => void;
    alert: (arg1: AcceptedType, arg2?: AcceptedType) => void;
};

interface ToggleSwitchProps {
    firstButton: string;
    secondButton: string;
    handleClick: (selected: string) => void;
    selected: string;
}
declare const ToggleSwitch: React__default.FC<ToggleSwitchProps>;

interface AvatarProps {
    /**
   * This property determines the size of the avatar. It can be set to 'small', 'medium', or 'large'.
   */
    variant?: 'small' | 'medium' | 'large';
    /**
     * This property allows you to customize the background color of the avatar.
     */
    backgroundColor?: string;
    /**
     * This property specifies the name of the icon to be displayed within the avatar.
     */
    iconName?: string;
    /**
     * This property allows you to customize the color of the icon within the avatar.
     */
    iconColor?: string;
    /**
     * This property allows you to set a custom size for the avatar, overriding the default size specified by the variant property.
     */
    customAvatarSize?: number;
    /**
     * This property allows you to set a custom size for the icon within the avatar.
     */
    customIconSize?: number;
    /**
    * This property specifies the label to display inside the avatar, used as an alternative to the icon.
    */
    label?: string;
    /**
     * This property allows you to customize the font size of the label inside the avatar.
     */
    labelFontSize?: string;
}

declare const Avatar: React__default.FC<AvatarProps>;

interface LineLoaderProps {
    logo?: React__default.FC;
    overlay?: boolean;
}

declare const LineLoader: React__default.FC<LineLoaderProps>;

interface ContentCardProps {
    contentHeader: string;
    data: Record<string | number, string | number>;
    maxHeight?: string;
}

declare const ContentCard: FC<ContentCardProps>;

interface IconProps$1 {
    /** Name of the icon to be displayed. */
    name: string;
    /** Optional click handler function for the icon. */
    onClick?: () => void;
}
interface DropdownOption$1 {
    /** Unique identifier for the dropdown option. */
    id: number;
    /** Value associated with the dropdown option. */
    value: string;
    /** Label displayed for the dropdown option. */
    label: string;
}
interface LabelEditTextFieldTypes$1 {
    /** Label text displayed above the input field. */
    label?: string;
    /** Initial text displayed in the input field. */
    text?: string;
    showText?: boolean;
    /** Text to be highlighted within the displayed text, if provided. */
    highlightText?: string;
    /** Custom error message to be displayed, if applicable. */
    customError?: string;
    /** Confirm icon properties including icon name and click handler. */
    confirmIcon?: IconProps$1;
    /** Cancel icon properties including icon name and click handler. */
    cancelIcon?: IconProps$1;
    /** Type of input field - standard text field or text field with a dropdown. */
    variant?: 'textFieldWithDropdown' | 'textField';
    /** Array of dropdown options used if the dropdown variant is selected. */
    dropdownData?: DropdownOption$1[];
    /** Width of the input field component. */
    width?: string;
    /** Height of the input field component. */
    height?: string;
    /** Function called when confirming input changes, with input and dropdown values as arguments. */
    confirmAction?: (inputValue: string, dropdownValue: string) => void;
    isOpen?: boolean;
    /**for conditionally handle custom error */
    customErrorCondition?: boolean;
    placeholder?: string;
    onClick?: () => void;
    /** Function called when every input character got changed */
    onInputChange?: (newInputValue: string) => void;
    className?: string;
    tooltip?: {
        tooltipTitle?: string;
        tooltipPlacement?: string;
    };
    onDoubleClick?: () => void;
    disableEditing?: boolean;
}

declare const LabelEditTextField: FC<LabelEditTextFieldTypes$1>;

interface IconProps {
    /** Name of the icon to be displayed. */
    name: string;
    /** Optional click handler function for the icon. */
    onClick?: () => void;
    /** Optional color for the icon. */
    color?: string;
    /** Optional height for the icon. */
    height?: number;
    /** Optional width for the icon. */
    width?: number;
    /** Optional className for the icon. */
    className?: string;
}
interface DropdownOption {
    /** Unique identifier for the dropdown option. */
    id: number;
    /** Value associated with the dropdown option. */
    value: string;
    /** Label displayed for the dropdown option. */
    label: string;
}
interface LabelEditTextFieldTypes {
    /** Label text displayed above the input field. */
    label?: string;
    /** Initial text displayed in the input field. */
    text: string;
    /** Text to be highlighted within the displayed text, if provided. */
    highlightText?: string;
    /** Custom error message to be displayed, if applicable. */
    customError?: string;
    /** Confirm icon properties including icon name and click handler. */
    confirmIcon?: IconProps;
    /** Cancel icon properties including icon name and click handler. */
    cancelIcon?: IconProps;
    editIcon?: IconProps;
    /** Type of input field - standard text field or text field with a dropdown. */
    variant?: 'textFieldWithDropdown' | 'textField';
    /** Array of dropdown options used if the dropdown variant is selected. */
    dropdownData?: DropdownOption[];
    /** Width of the input field component. */
    width?: string;
    /** Height of the input field component. */
    height?: string;
    /** Function called when confirming input changes, with input and dropdown values as arguments. */
    confirmAction?: (inputValue: string, dropdownValue: string) => void;
    isOpen?: boolean;
    /**for conditionally handle custom error */
    customErrorCondition?: boolean;
    onClick?: () => void;
    nameTooltipTitle?: string;
}

declare const EditTextField: FC<LabelEditTextFieldTypes>;

/** A cell coordinates in the spreadsheet */
type Point = {
    /** The cell's column */
    column: number;
    /** The cell's row */
    row: number;
};

type ContextMenuState = {
    open: boolean;
    contextType: 'sheet' | 'column' | 'row' | 'cell' | null;
    options: optionsType[];
};
type optionsType = {
    label: string;
    value: string;
    iconName: string;
    action: () => void;
    disableTooltip: string;
    visible: boolean;
    disable: boolean;
};

interface ExcelFileProps {
    /**
     * The Excel data containing all the sheets and their respective content.
     */
    excelData: WorkSheet[];
    /**
     * Make the Excel Sheet Freeze or Editable using the boolean key.
     */
    editable?: boolean;
    /**
     * Optional configuration for the context menu (usually shown on right-click).
     * This allows customization of the context menu options with a label, value, icon, and action to be performed.
     * open: boolean;
     * Whether the context menu should be enabled (open or not).
     * If set to true, the context menu will be shown, otherwise, it will be disabled.
     * options: optionsType[];
     * Array of options available in the context menu. Each option contains a label (display name),
     * value (identifier), iconName (icon to display), and action (function to be executed on click).
     */
    contextOption?: ContextMenuState;
    /**
     * Controls whether the toolbar is shown or hidden.
     * Possible values:
     * - 'show' to display the toolbar
     * - 'hide' to hide the toolbar
     */
    toolbar?: 'show' | 'disable' | 'hide';
    /**
     * Controls whether the sheet navigation bar (tabs) is shown or hidden.
     * Possible values:
     * - 'show' to display the sheet bar
     * - 'hide' to hide the sheet bar
     * - 'readOnly' to view the sheet bar
     */
    sheetBar?: 'show' | 'readOnly' | 'hide';
    /**
     * Optional: The total number of rows in the Excel sheet.
     * This helps in determining the size and content of the sheet.
     */
    rowCount?: number;
    /**
     * Optional: The total number of columns in the Excel sheet.
     * This helps in determining the structure of the sheet.
     */
    colCount?: number;
    onSave?: (saveData: SaveData[], headerOldNewData?: {
        sheetName: string;
        headers: {
            newData: string;
            oldData: string;
        }[];
    }[]) => void;
    onSaveInfoChange?: (info: string) => void;
    /**
     * Delay time (in milliseconds) before the onSave callback is executed.
     */
    onSaveDelay?: number;
    /**
     * Optional: Sets the vertical (Y-axis) positioning of the context menu.
     * This allows precise control over where the context menu appears on the screen.
     */
    contextHeightPositioning?: number;
    /**
     * Optional: Sets the horizontal (X-axis) positioning of the context menu.
     * This allows precise control over where the context menu appears on the screen.
     */
    contextWidthPositioning?: number;
    /**
     * Optional: Dynamically sets the height of the sheet view area.
     * This can be useful if you want to change the height of the sheet display.
     */
    sheetHeight?: string;
    /**
     * Optional: Enables or disables the context menu for columns.
     * When set to true, column-related context menu actions are enabled.
     */
    columnContextEnable?: boolean;
    /**
     * Optional: Enables or disables the context menu for rows.
     * When set to true, row-related context menu actions are enabled.
     */
    rowContextEnable?: boolean;
    sheetBarContextEnable?: boolean;
    minimumColumnWidth?: number;
    showHider?: boolean;
    scroller?: boolean;
    attachmentAction?: {
        addAttachment: (file: File) => Promise<string>;
        deleteAttachment: (fileId: string) => Promise<string>;
        viewAttachment: (fileId: string, fileName: string) => Promise<void>;
    };
    disableDeleteOption?: boolean;
    maxRowLimit?: number;
    maxColLimit?: number;
    maxSheetLimit?: number;
    getActiveCell?: (cell: {
        value: string;
        active: Point;
    }) => void;
}
declare const ExcelFile: React__default.FC<ExcelFileProps>;

interface ModuleChipProps {
    /**
     * mandatory | label for the ModuleChip component
     */
    label: string;
    /**
     * mandatory | isActive for the ModuleChip component
     */
    isActive: boolean;
    /**
     * mandatory | onClick for the ModuleChip component
     */
    onClick: () => void;
    isFilterChip?: boolean;
}

declare const ModuleChip: React.FC<ModuleChipProps>;

interface IconRadialChartProps {
    radius: number;
    lineWidth: number;
    label: string;
    percentageValue: number;
    icon?: string;
    fontSize?: number;
    labelColor?: string;
    arcColor?: string;
    backgroundArcColor?: string;
    isSelectedArch?: boolean;
    onSelect?: () => void;
}

declare const IconRadialChart: React__default.FC<IconRadialChartProps>;

interface AttachMediaProps {
    /**
     * The image source to display.
     */
    mediaSrc: string;
    /**
     * Function triggered when the expand icon is clicked.
     */
    onExpandClick: () => void;
    /**
     * Function triggered when the delete icon is clicked.
     */
    onDeleteClick: (mediaSrc: string) => void;
    /**
     * Function triggered when the download icon is clicked.
     */
    onDownloadClick: () => void;
    /**
     * Custom height for the component.
     */
    height?: string;
    /**
     * Custom width for the component.
     */
    width?: string;
    mediaType: string;
    fileName?: string;
    fileId: string;
    thumbnailMediaSrc?: string;
    isDelete: boolean;
}

declare const AttachMedia: React__default.FC<AttachMediaProps>;

interface CardProps$1 {
    /** The icon to display in the card */
    icon: string;
    /** The status of the card (Passed, Failed, Warning, Skipped, Flaky) */
    status: 'Passed' | 'Failed' | 'Warning' | 'Skipped' | 'Flaky' | 'Total Defects' | 'Defect Density' | 'Open Defects' | 'Closed Defects' | 'Quality Score';
    /** The number displayed in the card */
    count: number | string;
    /** The description text displayed at the bottom of the card */
    text: string;
    /** Inline Styling */
    style?: React.CSSProperties;
    /** toggle update */
    handleToggleStatus?: (_status: boolean) => void;
    /** make Card Select false */
    resetToggle?: boolean;
    /** call back */
    onSelectedStatus?: (_status: string) => void;
}

declare const StatusCard: React__default.FC<CardProps$1>;

interface DyanamicObj {
    [key: string]: any;
}
interface EditorProps {
    /**
     * Editor Content Type
     */
    language: 'javascript' | 'html' | 'json' | 'plain text' | 'xml';
    /**
     *
     *Width of the editor
     */
    width: string;
    /**
     * Height of the editor
     */
    height: string;
    /**
     * read only
     */
    readOnly?: boolean;
    /**
     * Variable options list
     */
    variableOptionsList?: [] | DyanamicObj[];
    /**
     *Value to set in the editor
     */
    value: string;
    /**
     *
     * setter function to set the value for the editor
     */
    setValue: (value: string) => void;
    /**
     * onChange function to handle the input changes
     */
    handleChange: (value: string | undefined, _event: any) => void;
    /**
     * Theme
     */
    theme?: 'light' | 'vs-dark';
    /**
     * type of editor
     */
    isRequisiteType?: boolean;
    /**
     * onPaste
     */
    onPaste?: (pastedContent: string) => void;
    /**
     * If passed true, it will show the variable dropdown
     */
    showVariableDropdown?: boolean;
    /**
     * Defaukt value for the editor
     */
    defaultValue?: string;
}
interface dropdownPositionType {
    top: number;
    left: number;
}
interface VariableDropdownProps {
    /**
     * Position whether absoloute or relative
     */
    position: 'absolute' | 'relative';
    /**
     * Dropdown width
     */
    width: string;
    /**
     * Dropdown height
     */
    height?: string;
    /**
     * List of variables
     */
    optionsList: DyanamicObj[];
    /**
     * Function to handle click on variable
     */
    onSelectVariable: (variable: object) => void;
    /**
     * Dropdown position used for dropdown placement
     */
    dropdownPosition?: dropdownPositionType;
    /**
     * Dropdown zIndex used for dropdown placement
     */
    zIndex?: number;
    /**
     * number of characters upto which the options will get truncated
     */
    truncateTextValue?: number;
}

declare const VariableDropdown: FC<VariableDropdownProps>;

interface LineChartProps {
    data: any[];
    width: number;
    height: number;
    axisColor: string;
    isStatusVariant?: boolean;
    lineChartWidth?: number;
    yAxisLabel?: string;
    xAxisLabel?: string;
    yAxisValueColor?: string;
    xAxisColor?: string;
    yAxisColor?: string;
    yAxisLabelColor?: string;
    textSize?: string | number;
    fontWeight?: string | number;
    numberSize?: string | number;
    proportionalSpacing?: boolean;
    shouldCenterSinglePoint?: boolean;
    chartName?: string;
    xAxisLabelGap?: number;
}

declare const LineChart: React__default.FC<LineChartProps>;

interface DownloadClientProps {
    /**
     * Close dialog function to close the modal dialog
     **/
    onClose: () => void;
    /**
     * distance between modal dialog and parent from top
     **/
    top?: string;
    /**
     * distance between modal dialog and parent from left
     **/
    left?: string;
    /**
     * To be used custom properties for the modal dialog through className
     **/
    className?: string;
    /**
     * Description of the dialog box
     **/
    description?: string;
    /**
     * Download button function
     **/
    onClick?: (os: string) => void;
    optionZIndex?: number;
}

declare const DownloadClient: React.FC<DownloadClientProps>;

interface fieldSetProps {
    legendName: string;
    height: string;
    width: string;
    children: ReactNode | string;
}

declare const FieldSet: FC<fieldSetProps>;

declare const CreateVariableSlider: FC<CreateVariableProps>;

interface ColumnProps$1 {
    /**
     * 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$2 {
    /**
     * data for each row
     */
    [key: string]: any;
}
interface TableProps$1 {
    /**
     * Column details for table
     */
    tableMeta: Array<ColumnProps$1>;
    /**
     * Data for table
     */
    tableData: Array<DataProps$2>;
    /**
     * Table type
     */
    accordionType: 'row' | 'column';
    /**
     *  Specific sentence to be displayed data not found
     */
    noDataContent?: string | ReactNode;
    /**
     * 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';
    /**
     * Accordion collapse and expand Icon width
     */
    TableAccordionStateIconWidth: number;
    /**
     * Accordion collapse and expand Icon height
     */
    TableAccordionStateIconHeight: number;
    highlightText?: string;
}

declare const TableWithAccordion: ({ highlightText, tableMeta, tableData, accordionType, noDataContent, height, withFixedHeader, headerType, TableAccordionStateIconWidth, TableAccordionStateIconHeight, }: TableProps$1) => react_jsx_runtime.JSX.Element;

interface ProgressBarProps {
    progressPercentage?: number;
    color?: string;
    trackColor?: string;
    height?: number;
    label?: string;
    showPercentage?: boolean;
    percentageFontSize?: number;
    percentageTextColor?: string;
    labelFontSize?: number;
    labelTextColor?: string;
    usedMemory?: string;
    totalMemory?: string;
    progressBarWidth?: string | number;
}

declare const ProgressBar: React__default.FC<ProgressBarProps>;

interface ChooseFileProps {
    /**
     * Variant of the button
     */
    variant: 'primary' | 'secondary' | 'tertiary' | 'delete' | 'warning';
    /**
     * What background color to use
     */
    backgroundColor?: string;
    /**
     * Width in string format can be sent for needed width
     */
    buttonWidth?: string;
    /**
     * Height in string format can be sent for needed height
     */
    buttonHeight?: 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.MouseEvent<HTMLButtonElement, MouseEvent>) => void;
    /**
     * Button id
     */
    id?: string;
    /**
     * onSubmit function handler
     */
    onSubmit?: (event: React.MouseEvent<HTMLButtonElement, MouseEvent>) => void;
    /**
     * react ref for the button
     */
    ref?: any;
    /**
     * Classname for the button
     */
    className?: string;
    /**
     * Additional styles for the button
     */
    style?: React.CSSProperties;
    /**
     * Give icon name availble in storybook that to be on left side of button
     */
    iconName?: string;
    /**
     * isChooseFile is a Boolean prop
     */
    isChooseFile?: boolean;
    /**
     * selectedfile object will be send.
     */
    selectedFile?: File | DynamicObj | null;
    /**
     * handleCloseIcon function will set to the initial state .
     */
    handleCloseIcon?: () => void;
    /**
     * Is the Type ChooseFile Action Mandatory.
     */
    isMandatory?: boolean;
}

declare const ChooseFile: FC<ChooseFileProps>;

interface ScriptSwitchButtonProps {
    handleClick: (selected: string) => void;
    selected: string;
    tabList: Array<'Automation' | 'Manual'>;
}
declare const ScriptSwitchButton: React__default.FC<ScriptSwitchButtonProps>;

interface TabConfig {
    /**
     * This property specifies the name of the tab.
     * It is used to uniquely identify each tab.
     */
    name: string;
    /**
     * This property specifies the name of the icon to be displayed within the tab.
     */
    icon: string;
    /**
     * This property specifies the tooltip text to be displayed when hovering over the tab.
     */
    tooltip: string;
}
/**
 * This interface defines the props for the `SwitchButton` component.
 */
interface SwitchButtonProps {
    /**
     * This callback function is triggered when a tab is clicked.
     * It receives the name of the selected tab as an argument.
     */
    handleClick: (selected: string) => void;
    /**
     * This property specifies the currently selected tab by name.
     */
    selected: string;
    /**
     * This property defines the list of tabs to be displayed within the `SwitchButton` component.
     * Each tab is represented by the `TabConfig` interface.
     */
    tabList: TabConfig[];
}

declare const SwitchButton: React__default.FC<SwitchButtonProps>;

type MediaPreviewProps = {
    onModalClose?: () => void;
    MediaSrc: string;
    fileName?: string;
    onDeleteClick?: (src: string) => void;
    mediaType: string;
    fileId: string;
    thumbnailMediaSrc?: string;
    isDelete?: boolean;
    onExpandClick?: (fileId?: string) => void;
    onDownloadClick?: (fileId?: string) => void;
    isMediaIcon?: boolean;
    previewOnly?: boolean;
    iconName?: string;
    isDisabled?: boolean;
};

declare const MediaPreview: React__default.FC<MediaPreviewProps>;

interface NavBarIcon {
    name: string;
    [key: string]: any;
}
interface MobileSkinProps {
    children: React.ReactNode | string;
    orientation?: 'portrait' | 'landscape';
    navBarIcons?: NavBarIcon[];
    topNavBarIcons?: NavBarIcon[];
    mobileHeight?: number;
    mobileWidth?: number;
    UtilityBar?: boolean;
    background?: string;
    tooltip?: Record<string, string>;
    navBarPosition?: 'top' | 'bottom' | 'left';
    tooltipFormatter?: ((title: string) => React.ReactNode) | undefined;
}

declare const MobileSkin: React__default.FC<MobileSkinProps>;

interface promptProp {
    width?: number;
    height?: number;
    placeholder?: string;
    iconName?: string;
    iconPosition?: string;
    borderRadius?: number;
    autoFocus?: boolean;
    iconHeight?: number;
    iconWidth?: number;
    iconColor?: string;
    tooltipTitle?: string;
    value: string;
    disableInput?: boolean;
    isAdditionalIcon?: boolean;
    additionalIconName?: string;
    onAdditionalIconClick?: () => void;
    additionIconToolTip?: string;
    onPromptChange?: (event: React.ChangeEvent<HTMLInputElement>) => void;
    onBlur?: (event: React.FocusEvent<HTMLInputElement>) => void;
    onFocus?: (event: React.FocusEvent<HTMLInputElement>) => void;
    submitPrompt?: (query: string) => void;
}

declare const Prompt: React__default.ForwardRefExoticComponent<promptProp & React__default.RefAttributes<HTMLInputElement>>;

interface MessageBoxProps {
    content?: React.ReactNode;
    isVisible: boolean;
    maxWidth?: number;
    onClick?: (event: React.MouseEvent<HTMLInputElement>) => void;
    isClickable: boolean;
    arrowPosition: 'left' | 'right';
}

declare const MessageBox: React__default.FC<MessageBoxProps>;

interface ChatModalProps {
    iconName: string;
    modalWidth: number;
    modalHeight: number;
    headerContent?: React.ReactNode;
    footerContent?: React.ReactNode;
    iconPosition: {
        top?: number;
        left?: number;
        bottom?: number;
        right?: number;
    };
    hoverIconPosition: {
        top?: number;
        left?: number;
        bottom?: number;
        right?: number;
    };
    modalPosition: {
        top?: number;
        left?: number;
        bottom?: number;
        right?: number;
    };
    children: ReactNode;
    iconHeight?: number;
    iconWidth?: number;
    modalHeading?: string;
    onClearChat?: () => void;
}

declare const ChatModal: React__default.FC<ChatModalProps>;

interface ChatModalRef {
    closeModal: () => void;
}
interface ChatModalAiProps {
    iconName: string;
    modalWidth: number;
    modalHeight: number;
    headerContent?: React.ReactNode;
    footerContent?: React.ReactNode;
    iconPosition: {
        top?: number;
        left?: number;
        bottom?: number;
        right?: number;
    };
    hoverIconPosition: {
        top?: number;
        left?: number;
        bottom?: number;
        right?: number;
    };
    modalPosition: {
        top?: number;
        left?: number;
        bottom?: number;
        right?: number;
    };
    children: ReactNode;
    iconHeight?: number;
    iconWidth?: number;
    hoverTitle?: string;
    onVisibilityChange?: (visible: boolean) => void;
}

declare const ChatModalAi: React$1.ForwardRefExoticComponent<ChatModalAiProps & React$1.RefAttributes<ChatModalRef>>;

interface HistoryCardProps {
    /**
     * Is this the principal call to action on the page?
     */
    variant: 'primary' | 'danger' | 'success' | 'warning';
    /**
     * Details to display the title
     */
    title: React.ReactNode;
    /**
     * Header for the tab
     */
    tabTitle: string;
    /**
     * 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, tabTitle, comment, profileShortName, }: HistoryCardProps) => react_jsx_runtime.JSX.Element;

interface ToggleAiIconProps {
    onChange?: (event: React.MouseEvent<HTMLInputElement, MouseEvent>) => void;
    disabled?: boolean;
    checked?: boolean;
    id?: string;
    path?: string;
}

declare const AiToggle: React__default.FC<ToggleAiIconProps>;

interface AnimatedSettingProps {
    name: string;
    className?: string;
    height?: number;
    width?: number;
    color?: string;
    onClick?: (data?: any) => void;
    hoverEffect?: boolean;
    isSelected?: boolean;
    disabled?: boolean;
    variant?: 'dark' | 'light' | 'danger';
    x?: string;
    y?: string;
    chartIcon?: boolean;
    tabIndex?: number;
    path?: string;
}

declare const AnimatedSetting: React$1.ForwardRefExoticComponent<AnimatedSettingProps & React$1.RefAttributes<HTMLSpanElement>>;

interface PromptContainerProps {
    id?: number | string | null | undefined;
    serialNumber?: number | string;
    children: React.ReactNode;
    onContainerClick: () => void;
    onIconClick: (action: string) => void;
    numberChildren: React.ReactNode;
    onNextClick: () => void;
    onPreviousClick: () => void;
    activeId?: number | null | string;
    setActiveId: (id: number | string | null) => void;
    isActive?: boolean;
    disabled?: boolean;
    isEditAccess?: boolean;
    isViewAccess?: boolean;
    versionsLength?: number;
    count?: number;
    hiddenActions?: string[] | string;
}

declare const PromptContainer: React__default.FC<PromptContainerProps>;

interface LinkProps {
    /**
     * Name | name of the input field
     */
    name: string;
    /**
     * Label | field label to be displayed
     */
    label?: string;
    /**
     * value | input field value
     */
    value: string;
    /**
     * error | If true, error message will be displayed
     */
    error?: boolean;
    /**
     * helperText | error, success, warning message to be shown
     */
    helperText?: string;
    /**
     * variants to set color/style of the input field
     */
    variant?: 'default' | 'primary';
    /**
     * type to set color/style of the input field
     */
    type: 'text' | 'password' | 'number' | 'email' | 'url' | 'time';
    /**
     * to disable the input field
     */
    disabled?: boolean;
    /**
   * to disable the link icon
   */
    disableLinkIcon?: 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;
    /**
     * noBorder prop 'true' removes border of input
     */
    noBorder?: boolean;
    /**
     * onChange, onKeyDown, onBlur, onFocus actions
     */
    onChange?: (event: React.ChangeEvent<HTMLInputElement>, item?: any) => void;
    onKeyDown?: (event: React.KeyboardEvent<HTMLInputElement>) => void;
    onBlur?: (event: React.FocusEvent<HTMLInputElement>) => void;
    onFocus?: (event: React.FocusEvent<HTMLInputElement>) => void;
    onClick?: (event: React.MouseEvent<HTMLInputElement>) => void;
    onKeyUp?: (event: React.KeyboardEvent<HTMLInputElement>) => void;
    /**
     * id to select the input field uniquely
     */
    id?: string;
    /**
     * if on, suggestion popup will be displayed
     */
    autoComplete?: 'on' | 'off';
    /**
     * if true, input field is in autofocus state
     */
    autoFocus?: boolean;
    /**
     *  minimum and maximum values for the number type input field and their functions
     */
    minValue?: number;
    maxValue?: number;
    /**
     * background of the input field prop
     */
    transparentBackground?: boolean;
    /**
     * size for the input field
     */
    size?: 'small' | 'medium';
    /**
     * isLabelRequired for the input field without label,showing placeholder
     */
    isLabelRequired?: boolean;
    isViewMode?: boolean;
}

declare const Link: React$1.ForwardRefExoticComponent<LinkProps & React$1.RefAttributes<HTMLInputElement>>;

interface ChipsWithCountProps {
    /**
     * The text to be displayed on the Chip and remaining as the count.
     */
    labelsList: string[];
}

declare const ChipWithCount: FC<ChipsWithCountProps>;

interface EditLabelProps {
    onConfirm?: (_text: string, _selectedOption?: Option$2) => void;
    onCancel?: () => void;
    onClick?: () => void;
    handleCustomError?: (inputText: string) => string;
    value?: string;
    label?: string;
    optionsList?: Option$2[];
    selectedOption?: Option$2;
    withDropdown?: boolean;
    inputFieldWidth?: number;
    selectFieldWidth?: number;
    textColor?: string;
    required?: boolean;
    isDisable?: DisabledOptions;
    tooltip?: {
        tooltipTitle?: string;
        tooltipPlacement?: 'bottom' | 'top' | 'left' | 'right' | 'top-start' | 'top-end' | 'bottom-start' | 'bottom-end';
    };
    highlightText?: string;
    id?: string;
    isEditable?: boolean;
    setIsEditable?: (id: string | null) => void;
    cursor?: string;
    isOnBlurTrue?: boolean;
    handleOnChange?: (e: React.ChangeEvent<HTMLInputElement>) => void;
    handleTriggerDoubleClick?: () => void;
    truncatedTextCount?: number;
    confirmIconTooltip?: string;
    cancelIconTooltip?: string;
    inlineValidationError?: boolean;
    onChangeValidationError?: boolean;
    truncatedType?: 'count' | 'pixel';
}
type OptionValue$1 = any;
type DisabledOptions = {
    confirm?: boolean;
    cancel?: boolean;
    textField?: boolean;
};
interface Option$2 {
    [key: string]: OptionValue$1;
}

declare const EditLabel: ({ id, onConfirm, onCancel, handleCustomError, value, label, optionsList, selectedOption, withDropdown, inputFieldWidth, selectFieldWidth, textColor, tooltip, required, isDisable, onClick, highlightText, isEditable, setIsEditable, cursor, isOnBlurTrue, handleOnChange, handleTriggerDoubleClick, truncatedTextCount, truncatedType, confirmIconTooltip, cancelIconTooltip, inlineValidationError, onChangeValidationError, }: EditLabelProps) => react_jsx_runtime.JSX.Element;

interface ErrorBoundaryProps {
    fallback: ReactNode;
    children: ReactNode;
}
interface ErrorBoundaryState {
    hasError: boolean;
}

declare class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
    constructor(props: ErrorBoundaryProps);
    static getDerivedStateFromError(): ErrorBoundaryState;
    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
    render(): React$1.ReactNode;
}

interface AddContentButtonProps {
    iconName?: string;
    onButtonClick?: () => {} | void;
    buttonLabel: string;
    buttonText: string;
    disableButton?: boolean;
    stepCount?: string | number;
    iconWidth?: number;
    iconHeight?: number;
    addContentLabel?: string;
}

declare const AddContentButton: React__default.FC<AddContentButtonProps>;

interface TabsProps {
    /**
     * An array of tab objects containing label, component, and optional disabled status.
     */
    tabsData: {
        id: string;
        label: string;
        component?: JSX.Element;
        disabled?: boolean;
        count?: number | string;
        status?: 'success' | 'error' | 'transparent';
    }[];
    /**
     * Defines the styling variant of the tabs.
     */
    variant?: 'default' | 'capsule';
    /**
     * activeTabId : The ID of the currently active tab.
     */
    activeTabId: string;
    /**
     * onTabClick : function updates the active tab state when a user interacts with the tabs,
     */
    onTabClick: (id: string) => void;
    /**
     * noBorder:true , removes the outer border from tabs
     */
    noBorder?: boolean;
    noPadding?: boolean;
    /**
     * titleSize is to accpect dynamic font size
     */
    titleSize?: number | string;
}

declare const TabsWithSilder: ({ variant, tabsData, activeTabId, onTabClick, noBorder, noPadding, titleSize, }: TabsProps) => react_jsx_runtime.JSX.Element;

interface StatusIndicatorProps {
    label: string;
    iconName?: string;
    onClick?: (event: React.MouseEvent<HTMLButtonElement, MouseEvent>) => void;
    isDisable?: boolean;
    backgroundColor: boolean;
    border: boolean;
    variant: string;
}

declare const StatusIndicator: React$1.ForwardRefExoticComponent<StatusIndicatorProps & React$1.RefAttributes<HTMLButtonElement>>;

/**
 * Props for the OsTree component.
 */
interface OsTreeProps {
    /**
     * Label for the root node of the tree.
     */
    rootLabel: string;
    /**
     * Array of labels for the children nodes of the root.
     */
    childrenLabels: string[];
    /**
     * Direction of the tree layout.
     * Can be "horizontal" or "vertical".
     * @default "horizontal"
     */
    direction?: 'horizontal' | 'vertical';
    /**
     * Alignment of the tree nodes based on the direction.
     * For vertical layout: "left", "center", "right"
     * For horizontal layout: "top", "center", "bottom"
     * @default "center"
     */
    align?: 'left' | 'center' | 'right' | 'top' | 'bottom';
}

declare const OsTree: React__default.FC<OsTreeProps>;

interface OtpVerificationProps {
    /**
     * Function to handle the closing of the OTP verification popup.
     */
    handleClose: () => void;
    /**
     * Function to handle the action when user clicks on "Resend OTP".
     */
    handleResend: () => void;
    /**
     * Function to handle OTP validation on submit. Receives the entered OTP as a string.
     */
    handleOtp: (otp: string) => void;
    /**
     * Optional timeout in seconds before the user can resend the OTP again. Default is 30 seconds.
     */
    resendTimeout?: number;
}

declare const OtpVerification: React__default.FC<OtpVerificationProps>;

interface MediaViewerModalProps {
    isOpen: boolean;
    onClose: () => void;
    isPlaying: boolean;
    onTogglePlay?: () => void;
    mediaType: 'video' | 'image';
    src: string;
    headerTitle?: string;
    onDownload?: () => void;
    onExpand?: () => void;
    showHeader?: boolean;
    showDownload?: boolean;
    showExpand?: boolean;
    width?: string;
    height?: string;
    showControls?: boolean;
    customStyle?: React.CSSProperties;
    overlay?: boolean;
    children?: React.ReactNode;
}

declare const MediaViewerModal: React__default.FC<MediaViewerModalProps>;

interface SessionDropdownProps {
    header: string;
    secondaryHeader?: string;
    primaryCount?: string;
    secondaryCount?: string;
    primaryItems: React.ReactNode[];
    secondaryItems?: React.ReactNode[];
    width?: string;
    activeTab?: 'primary' | 'secondary';
    onPrimaryTabClick?: () => void;
    onSecondaryTabClick?: () => void;
    onDownloadClick?: () => void;
    onDeleteClick?: () => void;
    tabsData?: {
        id: string;
        label: string;
        count?: string | number;
        component?: ReactElement;
        disabled?: boolean;
    }[];
    activeTabId?: string;
    onTabClick?: (tabId: string) => void;
}

declare const SessionDropdown: React__default.FC<SessionDropdownProps>;

interface NewNode {
    sourceId?: string;
    payloadSourceId?: string;
    action?: 'addAbove' | 'addBelow' | 'addInside';
    type?: 'input' | 'inputWithDropdown';
    options?: [];
    selectedOption?: string;
    value?: string;
    error?: string;
    label?: string;
    confirmIconTooltip?: string;
    cancelIconTooltip?: string;
    firstNodeKey?: string;
}
declare type JSX$1 = ReactNode | JSX$1.Element[] | string | null;
type RootNode = {
    node: any;
    select: 'radio' | 'checkbox' | 'none';
    cell?: (row: any) => JSX$1;
    actions?: (row: any, treeRowRef?: React.RefObject<HTMLDivElement | null>) => JSX$1;
};
interface Column {
    name: string | JSX$1;
    accessor: string;
    width: string;
    isClickable?: boolean;
    cell?: (row: any) => JSX$1;
    actions?: (row: any, treeRowRef?: React.RefObject<HTMLDivElement | null>) => JSX$1;
    isTree?: boolean;
    defaultValue?: string;
    defaultActions?: () => JSX$1;
}
interface TreeTableProps {
    treeData: any;
    columnsData: Column[];
    selected?: string[];
    select?: 'radio' | 'checkbox' | 'none';
    onChange?: (e: any, node: string[] | any) => void;
    onClick?: (e: React.MouseEvent<HTMLDivElement>, row: TreeNodeProps) => void;
    onExpand?: (node: TreeNodeProps) => void;
    loadMore?: (_direction?: string) => void;
    tableBorder?: string;
    height?: number | string;
    newNode?: NewNode;
    onAddConfirm?: (_name: string, _type?: Option$1) => void;
    onAddCancel?: () => void;
    loading?: boolean;
    rootNode?: RootNode;
    getContentLength?: number;
    handleEditFieldError?: (inputText: string) => string;
    pagination?: boolean;
    selectedNode?: string;
    tableHeaderBgColor?: string;
    hideOnDisable?: boolean;
    freezeColumns?: number;
    scriptLengthTruncate?: number;
    addModuleInputWidth?: number;
    addModuleSelectWidth?: number;
    onScroll?: () => void;
    disableEditLabelConfirmIcon?: boolean;
    transparentHeader?: boolean;
    navigateTreeNode?: string | null;
    handleRemoveNavigateTreeNode?: () => void;
    scrollThreshold?: number;
}
type OptionValue = any;
interface Option$1 {
    [key: string]: OptionValue;
}

declare const TableTreeFn: React__default.ForwardRefExoticComponent<TreeTableProps & React__default.RefAttributes<HTMLDivElement>>;

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

type valueType = File | string;
declare const getExtension: (value: valueType) => string | undefined;
declare const getExtensionWithPeriod: (value: valueType) => string;

type AnyObject$1 = {
    id: number;
    [key: string]: any;
};
declare function findAndInsert<T extends AnyObject$1>(data: T[], key: keyof T, targetId: number, newEntry: T, insertPosition: 'above' | 'below' | 'replace', childrenKey?: string): {
    updatedArray: T[];
} | null;

declare const ffid: () => string;

type Callback$1 = (...args: any[]) => void;
interface DebouncedFunction extends Function {
    cancel: () => void;
}
declare const debounce: (func: Callback$1, delay: number) => DebouncedFunction;

/**
 * Compare two arrays for equality.
 * This function checks if both arrays contain the same elements in the same order,
 * including nested structures.
 *
 * @param arr1 - The first array to compare.
 * @param arr2 - The second array to compare.
 * @returns - A boolean indicating if the arrays are equal.
 */
declare const compareArrays: (arr1: unknown[], arr2: unknown[]) => boolean;

type AnyObject = Record<string, unknown>;
declare const compareObjects: (obj1: AnyObject | null, obj2: AnyObject | null) => boolean;

declare const getEncryptedData: (data: string, publicKey: string) => string | false;

type Callback = (...args: any[]) => void;
interface ThrottledFunction extends Function {
    cancel: () => void;
}
declare const throttle: (func: Callback, limit: number) => ThrottledFunction;

declare const truncateText: (text: string, maxLimit?: number, truncateType?: "count" | "pixel", fontSize?: number, fontFamily?: string) => string;
declare const isTextTruncated: (text: string, maxLimit?: number, truncateType?: "count" | "pixel", fontSize?: number, fontFamily?: string) => boolean;

type BarChartProps = {
    data: {
        label: string;
        value: number | string;
        id?: string;
        percent?: number;
        versions?: string[];
    }[];
    isYaxisSticky?: boolean;
    barWidth: number;
    height: number;
    barGap?: number;
    colors?: string[][];
    xAxisLabel?: string;
    isTruncateText?: boolean;
    yAxisLabel?: string;
    padding?: number;
    yAxisDivisions?: number;
    barBorderRadius?: number;
    legend?: boolean;
    showXAxisLabels?: boolean;
    icons?: (string | React__default.ReactNode)[];
    iconSize?: number;
    backgroundColor?: string;
    legendPosition?: 'top' | 'bottom';
    legendGap?: number;
    extendBarChartRightWidth?: number;
    isYAxisValuePercentage?: boolean;
    selectedBar?: string | null;
    setSelectedBar?: (value: string | null) => void;
    onSelectedBar?: (_label: string) => void;
    totalLabel?: string;
    customToolTip?: boolean;
    isOnclick?: boolean;
    isDashboardVersions?: boolean;
    type?: string;
    isMemory?: boolean;
    tooltipWidth?: string;
};
declare const BarChart: React__default.FC<BarChartProps>;

interface BarValue {
    value: number | string;
    arcColor: string | string[];
    arcBackgroundColor: string;
    barLabel: string;
}
type LegendType = 'numberLegend' | 'pillLegend';
interface MultiRadialChartProps {
    radius: number;
    lineWidth: number;
    fontSize: number;
    labelHeading: string;
    lineCap: 'square' | 'round';
    barValues: BarValue[];
    legendType?: LegendType;
    isLegendDetails?: boolean;
    isPillValueVisible?: boolean;
    labelFontSize?: number;
    subLabelFontSize?: number;
    gapAngle?: number;
    chartToLegendGap?: string;
    legendGap?: string;
    gapBetweenArch?: number;
    capsuleStyle?: object;
}

declare const MultiRadialChart: React__default.FC<MultiRadialChartProps>;

declare const Editor: React$1.ForwardRefExoticComponent<EditorProps & React$1.RefAttributes<any>>;

interface OperatingSystemInfo {
    osName: string;
    osVersion: string;
    hostName: string;
    iconName: string;
}
interface RunLevelExecutionDataSet$1 {
    peVariableSetId: string;
    peVariableSetName: string;
    globalVariableSetId: string;
    globalVariableSetName: string;
    testDataSetId: string;
    testDataSetName: string;
}
interface MachineExecutionInstance {
    id: string;
    clientId: string;
    numberOfRuns: string | number;
    executionEnv: string;
    browserName: string;
    browserVersion: string;
    systemUrl: string;
    machineInfo: OperatingSystemInfo;
    deviceInfo: any[];
    runLevelExecutionDataSets: RunLevelExecutionDataSet$1[];
    headless: boolean;
}
interface SequentialMachineInstance extends Omit<MachineExecutionInstance, 'runLevelExecutionDataSets'> {
    peVariableSetId: string;
    globalVariableSetId: string;
    testDataSetId: string;
    peVariableSetName: string;
    globalVariableSetName: string;
    testDataSetName: string;
}

declare const getSequentialPayload: (data: MachineExecutionInstance[]) => SequentialMachineInstance[];

type machineDataObj = any;
interface MachineData {
    [key: string]: machineDataObj;
}
interface RunLevelExecutionDataSet {
    peVariableSetId: string;
    globalVariableSetId: string;
    testDataSetId: string;
    runScriptCount?: number;
    [key: string]: any;
}
interface ConnectingNodeConfig {
    isButton?: boolean;
    isMultiSelect?: boolean;
    parentNodeData?: {
        [key: string]: any;
    };
    parentNodeIndex?: number;
    childNodeData?: {
        [key: string]: any;
    };
    childNodeIndex?: number;
    runLevelExecutionDataSetIndex?: number;
    runLevelExecutionDataSet?: RunLevelExecutionDataSet;
}
interface ConnectBranchProps {
    data: MachineData;
    noOfScripts?: number;
    childNodeCurveHeight?: number;
    getParentNodeComponent: (nodeArgs: ConnectingNodeConfig) => ReactElement;
    getParentNodeComponentActionItems: (nodeArgs: ConnectingNodeConfig) => ReactElement;
    getChildNodeComponent: (nodeArgs: ConnectingNodeConfig) => ReactElement;
    isReadOnlyMode?: boolean;
}

declare const ConnectingBranch: React__default.FC<ConnectBranchProps>;

declare const saveFileFromBlob: (blob: Blob, filename: string) => void;

declare const capitalize: (text: string) => string;

interface CommentType {
    id?: string | number;
    description?: string;
    createdBy?: string;
    modifiedBy?: string;
    createdByUname?: string;
    modifiedByUname?: string;
    createdOn?: string;
    modifiedOn?: string;
    name?: string;
    emailId?: string[];
    commentParentId?: string;
    comments: CommentType[];
    profileImage?: string | null;
}
interface CommentsProps {
    commentsData: CommentType[];
    handleAddComment: any;
    handleEditComment: any;
    handleDeleteComment: any;
    onCommentsDataChange?: (data: any) => void;
    currentUser?: {
        createdBy: string;
        modifiedBy: string;
        createdByUname: string;
        modifiedByUname: string;
    };
    isDisable?: boolean;
    userDetails?: any;
    createdByID?: string;
    createdBy?: string;
    rowBreakCharCount?: number;
    isVewMode?: boolean;
    showTextarea?: boolean;
    deleteEnable?: boolean;
    autoFocus?: boolean;
}

declare const Comments: ({ commentsData, handleAddComment, handleEditComment, handleDeleteComment, onCommentsDataChange, currentUser, isDisable, userDetails, createdByID, rowBreakCharCount, isVewMode, deleteEnable, showTextarea, autoFocus, }: CommentsProps) => react_jsx_runtime.JSX.Element;

declare const useFileDropzone: (options: DropzoneOptions) => DropzoneState;

declare const useClickOutside: (ref: React.RefObject<HTMLElement>, callback: () => void, ignoreRefs?: Array<React.RefObject<HTMLElement> | undefined>) => void;

type TriggerControl = {
    canTrigger: () => boolean;
    setTriggered: () => void;
    resetTrigger: () => void;
};
declare const useTriggerControl: () => TriggerControl;

interface PopUpModalProps {
    isOpen: boolean;
    onClose: () => void;
    onContinue?: () => void;
    titleMessage: string;
    subTitleMessage?: string;
    iconName: string;
    modalMessage: string | React.ReactNode;
    secondaryMessage?: string | React.ReactNode;
    firstButtonLabel?: string;
    secondButtonLabel?: string;
    buttonVariant: any;
    border: string;
    popupWidth?: string;
    popupHeight?: string;
    colorForTitleMessage?: string;
    footerContent?: React.ReactNode;
    firstButtonDisabled?: boolean;
    secondButtonDisabled?: boolean;
    zIndex?: number;
    iconSize?: number;
}

declare const PopUpModal: FC<PopUpModalProps>;

declare function formatString(input: string, removeSections?: string[]): string;

type dynamicObject$1 = {
    [key: string]: any;
};
type TestDataObject$1 = {
    _id: string;
    name: string;
    actualPath: string;
    searchKey: string;
    parentId: string;
};
interface ConditionalDropdownProps {
    /**
     * Label for the field
     */
    label?: string;
    /**
     * Value in the input should stored in this state
     */
    hashInputValue?: TestDataObject$1 | dynamicObject$1;
    /**
     * Function storing and updating the inputValue state
     */
    setHashInputValue?: (value: File | dynamicObject$1 | null) => void;
    /**
     * List of variables
     */
    variableList?: dynamicObject$1[];
    /**
     * Place holder for the input field
     */
    placeholder?: string;
    /**
     * Function to handle input change
     * @param value
     * @returns
     */
    onChange?: (event: React.ChangeEvent<HTMLInputElement>, dropdownItem?: dynamicObject$1) => void;
    /**
     * Function to handle create variable icon click
     */
    onCreateVariableClick?: () => void;
    /**
     * Width of the dropdown
     */
    dropdownWidth?: string;
    /**
     * Name | name of the input field
     */
    name?: string;
    /**
     * value | input field value
     */
    value?: string;
    /**
     * variants to set color/style of the input field
     */
    variant?: 'default' | 'primary';
    /**
     * type to set color/style of the input field
     */
    type?: 'text' | 'password' | 'number' | 'email' | 'url' | 'time';
    /**
     * error | If true, error message will be displayed
     */
    error?: boolean;
    /**
     * helperText | error, success, warning message to be shown
     */
    helperText?: string;
    /**
     * to disable the input field
     */
    disabled?: boolean;
    /**
     * if true, input field will be mandatory
     */
    required?: boolean;
    /**
     * classnames to style the input field
     */
    className?: string;
    /**
     * noBorder prop 'true' removes border of input
     */
    noBorder?: boolean;
    onKeyDown?: (event: React.KeyboardEvent<HTMLInputElement>) => void;
    onBlur?: (event: React.FocusEvent<HTMLInputElement>) => void;
    onFocus?: (event: React.FocusEvent<HTMLInputElement>) => void;
    /**
     * id to select the input field uniquely
     */
    id?: string;
    /**
     * if on, suggestion popup will be displayed
     */
    autoComplete?: 'on' | 'off' | 'new-password';
    /**
     *  minimum and maximum values for the number type input field and their functions
     */
    minValue?: string;
    maxValue?: string;
    /**
     * background of the input field prop
     */
    transparentBackground?: boolean;
    /**
     * size for the input field
     */
    size?: 'small' | 'medium';
    /**
     * isLabelRequired for the input field without label,showing placeholder
     */
    isLabelRequired?: boolean;
    /**
     * showHidePasswordIcon to hide or show the view password icon in input field
     */
    showHidePasswordIcon?: boolean;
    /**
     * If true, dropdown opens when '#' is entered at the first position.
     */
    isHash?: boolean;
    /**
     * Options for the dropdown when `isHash` is true.
     */
    dataFiles?: dynamicObject$1[];
    /**
     * a boolean prop to show add variable icon or not.
     */
    showAddVariableIcon?: boolean;
    onlyDropdown?: boolean;
    formProps?: Record<string, any>;
    readOnly?: boolean;
    height?: string;
}

declare const ConditionalDropdown: React$1.ForwardRefExoticComponent<ConditionalDropdownProps & React$1.RefAttributes<HTMLInputElement>>;

declare const hasDuplicateFile: (array: any[], property: string) => boolean;

interface PhoneInputProps {
    country: string;
    value: string;
    onChange: (phone: string) => void;
    onFocus?: (event: React.FocusEvent<HTMLInputElement>) => void;
    onBlur?: (event: React.FocusEvent<HTMLInputElement>) => void;
    width?: string;
    placeholder?: string;
    isValid: any;
    id: string;
    international?: boolean;
    dropdownStyle?: React.CSSProperties;
    enableAreaCodeStretch?: boolean;
    defaultCountry?: string;
    disabled?: boolean;
    isVerified?: boolean;
    isVerifyDisplay?: boolean;
    onVerifyClick?: () => void;
    onValidationChange?: (isValid: boolean) => void;
}

declare const PhoneInputField: React__default.FC<PhoneInputProps>;

type KeyboardAction = {
    key: string;
    action: () => void;
};

declare const useKeyboardActions: (actions: KeyboardAction[], ref?: RefObject<HTMLElement>) => void;

declare const rearrangeDragItem: (initialArray: any[], oldIndex: number, newIndex: number) => any[];

declare const formatResponseDate: (dateString: string | Date, format: "dd MMM yyyy" | "MMM dd yyyy" | "yyyy dd MM") => string;

declare const convertFormDataToObject: (formData: FormData) => Record<string, any>;

interface TreeDetailsResult {
    treeDataList: TreeNodeProps[];
    next: boolean;
    previous: boolean;
    startId: string;
    endId: string;
    root?: TreeNodeProps;
}
declare const getTreeDetails: (action: "above" | "below" | "expand" | "collapse" | "start" | "addAbove" | "addBelow" | "expandAll" | "collapseAll" | "show" | "hide" | "clone" | "delete" | "create" | "refresh", oldData: TreeNodeProps[], newData: TreeNodeProps[], sourceId?: string) => TreeDetailsResult;
declare const updateTreeState: (treeDataList: TreeNodeProps[], currentNode: TreeNodeProps) => TreeNodeProps[];

declare const useBeforeUnload: (beforeunload: boolean) => void;

declare const handleTreeNodeSect: (data: TreeNodeProps[], key: string | undefined, rootNode: TreeNodeProps | null, isChecked: boolean) => {
    data: TreeNodeProps[];
    rootNode?: TreeNodeProps | null;
};

/**
 * Updates selectedStatus to 'none' and optionally merges updates by key.
 *
 * @param tree Original tree (flat array)
 * @param updates Optional array of partial updates (matched by key)
 * @returns Updated tree
 */
declare function handleUnCheckAllTreeNodesWithUpdates(tree: TreeNodeProps[], updates?: Partial<TreeNodeProps>[]): TreeNodeProps[];

declare const handleTreeNodeExpandCollapse: (data: TreeNodeProps[], key: string | undefined, rootNode: TreeNodeProps | null, isExpanded: boolean, hidePrePostScript?: boolean) => {
    data: TreeNodeProps[];
    rootNode?: TreeNodeProps;
};

declare const formatDate: (date: Date) => string;

declare const addPrePostStepGroup: (steps: any[], stepId: string, newStep: any[]) => any[];
declare const addStepGroup: (oldData: any[], title: string, stepId: string, newSteps: any[]) => any[];

declare const convertToISO: (dateString: string) => Date;

declare const handleTimeZoneChange: (timeZone: string) => string;

type dynamicObject = {
    [key: string]: any;
};
type TestDataObject = {
    _id: string;
    name: string;
    actualPath: string;
    searchKey: string;
    parentId: string;
};
interface VariableSuggestionInputDropDownProps {
    /**
     * Label for the field
     */
    label?: string;
    /**
     * Value in the input should stored in this state
     */
    hashInputValue?: TestDataObject | dynamicObject;
    /**
     * Function storing and updating the inputValue state
     */
    setHashInputValue?: (value: File | dynamicObject | null) => void;
    /**
     * List of variables
     */
    variableList?: dynamicObject[];
    /**
     * Place holder for the input field
     */
    placeholder?: string;
    /**
     * Function to handle input change
     * @param value
     * @returns
     */
    onChange?: (event: React.ChangeEvent<HTMLInputElement>, item?: dynamicObject) => void;
    onPaste?: (event: React.ClipboardEvent<HTMLInputElement>) => void;
    /**
     * Function to handle create variable icon click
     */
    onCreateVariableClick?: () => void;
    /**
     * Function to clear input field on close icon click
     */
    handleClearInput?: () => void;
    /**
     * Width of the dropdown
     */
    dropdownWidth?: string;
    /**
     * Height of the dropdown
     */
    dropdownHeight?: string;
    /**
     * Name | name of the input field
     */
    name?: string;
    /**
     * value | input field value
     */
    value?: string;
    /**
     * variants to set color/style of the input field
     */
    variant?: 'default' | 'primary';
    /**
     * type to set color/style of the input field
     */
    type?: 'text' | 'password' | 'number' | 'email' | 'url' | 'time';
    /**
     * error | If true, error message will be displayed
     */
    error?: boolean;
    /**
     * helperText | error, success, warning message to be shown
     */
    helperText?: string;
    /**
     * to disable the input field
     */
    disabled?: boolean;
    /**
     * if true, input field will be mandatory
     */
    required?: boolean;
    /**
     * classnames to style the input field
     */
    className?: string;
    /**
     * noBorder prop 'true' removes border of input
     */
    noBorder?: boolean;
    onKeyDown?: (event: React.KeyboardEvent<HTMLInputElement>) => void;
    onBlur?: (event: React.FocusEvent<HTMLInputElement>) => void;
    onFocus?: (event: React.FocusEvent<HTMLInputElement>) => void;
    /**
     * id to select the input field uniquely
     */
    id?: string;
    /**
     * if on, suggestion popup will be displayed
     */
    autoComplete?: 'on' | 'off' | 'new-password';
    /**
     *  minimum and maximum values for the number type input field and their functions
     */
    minValue?: string;
    maxValue?: string;
    /**
     * background of the input field prop
     */
    transparentBackground?: boolean;
    /**
     * size for the input field
     */
    size?: 'small' | 'medium';
    /**
     * isLabelRequired for the input field without label,showing placeholder
     */
    isLabelRequired?: boolean;
    /**
     * If true, dropdown opens when '#' is entered at the first position.
     */
    isHash?: boolean;
    /**
     * If true, only hash dropdown will be shown without create variable icon.
     */
    isOnlyHash?: boolean;
    /**
     * Options for the dropdown when `isHash` is true.
     */
    dataFiles?: dynamicObject[];
    /**
     * a boolean prop to show add variable icon or not.
     */
    showAddVariableIcon?: boolean;
    formProps?: Record<string, any>;
    zIndex?: number;
    truncateTextValue?: number;
    getSelectedVariable?: (option: string) => void;
    symbol?: string;
    clearIcon?: boolean;
    /**
     * inputTitle for the field
     */
    inputTitle?: string;
    helperTextWidth?: number | string;
}

declare const VariableSuggestionInputDropDown: React$1.ForwardRefExoticComponent<VariableSuggestionInputDropDownProps & React$1.RefAttributes<HTMLInputElement>>;

interface DataProps$1 {
    /**
     * data for each row
     */
    [key: string]: any;
}
interface AddNlpProp$1 {
    action?: 'addBelow' | 'addLast' | 'replaceNlp' | 'EditNlp';
    nlpName?: string;
    sourceIndex?: number;
    id?: string;
}
interface SelectedItemProps {
    /**
     * selected row object | All selected flag
     */
    [key: string]: string | number | boolean;
}
interface PrePostTableProps {
    /**
     * 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' | 'tertiary';
    /**
     * 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;
    /**
     *  classNames for the table Header container
     */
    tableHeadClass?: string;
    /**
     *  classNames for the table Row container
     */
    tableBodyRowClass?: string;
    /**
     * custom color for the column text
     */
    headerTextColor?: 'default' | 'primary';
    /**
     * custom color for the row text
     */
    tableDataTextColor?: string;
    /**
     * icon for the table header, for expand or other purposes
     */
    headerIconName?: string;
    /**
     * handle function for the table header icon
     */
    headerIconOnClick?: () => void;
    /**
     * Drag and Drop pass true to enable
     */
    draggable?: boolean;
    /**
     * Drag and Drop indexes
     */
    onDragEnd?: (startIndex: number, endIndex: number) => void | undefined;
    loadMore?: (_direction?: string) => void;
    /**
     * enable editMode by setting state row id
     */
    editMode?: number | string;
    /**
      * The content that to be displayed if editComponent
      */
    editComponent?: ReactNode;
    /**
     * The content that to be displayed NlpInput Component
     */
    NlpComponent?: ReactNode;
    /**
    * state for the Add new Row in Table
    */
    AddNlp?: AddNlpProp$1 | undefined | null;
    /**
      * handle function for Drag Starting in the Table
      */
    handleDragStart?: () => void;
    loading?: boolean;
    handleViewComponent?: (_rowData: DataProps$1, _toggleViewRow: (_val: null) => void) => (() => ReactElement) | null;
    handleAccordion?: (row: any) => void;
    scriptType?: boolean;
}

declare const PrePostTable: React$1.ForwardRefExoticComponent<PrePostTableProps & React$1.RefAttributes<any>>;

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;
    extraInfo?: (e: any) => JSX.Element | string | ReactNode;
}
interface AddNlpProp {
    action?: 'addBelow' | 'addLast' | 'replaceNlp' | 'EditNlp';
    nlpName?: string;
    sourceIndex?: number;
}
interface DataProps {
    /**
     * data for each row
     */
    [key: string]: any;
}
interface TableProps {
    /**
     * Column details for table
     */
    tableMeta: Array<ColumnProps>;
    /**
     * Data for table
     */
    tableData: Array<DataProps>;
    /**
     *  Specific sentence to be displayed data not found
     */
    noDataContent?: string | ReactNode;
    /**
     * 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';
    onDragEnd?: (startIndex: number, endIndex: number) => void | undefined;
    editMode?: number | string;
    /**
     * The content that to be displayed if editComponent
     */
    editComponent?: ReactNode;
    /**
     * The content that to be displayed NlpInput Component
     */
    NlpComponent?: ReactNode;
    /**
     * state for the Add new Row in Table
     */
    AddNlp?: AddNlpProp | undefined | null;
    /**
     * handle function for Drag Starting in the Table
     */
    handleDragStart?: VoidFunction;
    handleAccordion?: (e: any) => void;
    /**
     * Event for checkbox onClick
     */
    onSelectClick?: (e: any) => void;
    /**
     * Check box feature to select the row
     */
    handleViewComponent?: (_rowData: DataProps, _toggleViewRow: (_val: null) => void) => (() => ReactElement) | null;
    loading?: boolean;
    isViewPrivilegeMode?: boolean;
    defaultExpanded?: 'Steps' | 'POST' | 'PRE' | 'Depends' | 'All';
    isHeaderRequired?: boolean;
    isClientSide?: boolean;
}

declare const StepLandingTable: React$1.ForwardRefExoticComponent<TableProps & React$1.RefAttributes<any>>;

interface RichTextEditorProps {
    convertedContent: string;
    label?: string;
    setConvertedContent: (content: string) => void;
    onBlur?: (event: React.FocusEvent<HTMLInputElement>) => void;
    readOnly?: boolean;
    toolbarHidden?: boolean;
    toolbarOptions?: string[];
    mode?: 'view' | 'edit';
    analyticsClasses?: boolean;
    descriptionContentNotEditable?: boolean;
    required?: boolean;
    helperText?: string;
    error?: boolean;
    editableTextEditor?: boolean;
    onSubmit?: (content: string) => void;
}

declare const TextEditor: FC<RichTextEditorProps>;

interface NoDataFoundProps {
    iconName: string;
    iconWidth?: number;
    iconHeight?: number;
    text?: string;
    textFontSize?: string;
    textDirectionRow?: boolean;
    gap?: string;
}

declare const NoDataContent: React__default.FC<NoDataFoundProps>;

type CardProperties = {
    width?: string;
    height?: string;
    background?: string;
    borderRadius?: string;
    boxShadow?: string;
    padding?: string;
    margin?: string;
    border?: string;
    className?: string;
    style?: CSSProperties;
    onClick?: () => void;
};
type HeaderContentProperties = {
    isHeader?: boolean;
    content?: JSX.Element;
};
type MidContentProperties = {
    isMidContent?: boolean;
    content?: JSX.Element;
};
type FooterContentProperties = {
    isFooter?: boolean;
    content?: JSX.Element;
};
type CardProps = {
    cardProperties?: CardProperties;
    headerContent?: HeaderContentProperties;
    midContent: MidContentProperties;
    footerContent?: FooterContentProperties;
    isSkeleton?: boolean;
};

declare const Card: FC<CardProps>;

declare const isEmptyObject: (obj: any) => boolean;

declare const toCamelCase: (str: string) => string;

declare const autoScrollToTableLastRow: (tableRef: React.RefObject<HTMLTableSectionElement>, extraCustomHeight?: number) => () => void;

declare const handleTreeExpandAllCollapseAll: (data: TreeNodeProps[], key: string, rootNode: TreeNodeProps | null, isExpanded: boolean, treeAction?: "expandAll" | "collapseAll" | undefined, hidePrePostScript?: boolean) => {
    data: TreeNodeProps[];
    rootNode?: TreeNodeProps;
};

type ScrollLogicalPosition = 'start' | 'center' | 'end' | 'nearest';
declare const scrollToView: (id: string | null | undefined, block?: ScrollLogicalPosition, retries?: number) => void;

declare function toggleShowHideEntity(data: TreeNodeProps[], isHide: boolean, isScript: boolean): TreeNodeProps[];

declare function getTopVisibleNodeKey(scrollContainerWrapper: HTMLDivElement, treeData: TreeNodeProps[]): string | null;

declare const nlpInputDelay: (ms: number) => Promise<void>;

declare const getNavigateToKey: (currentNode: TreeNodeProps, treeData: TreeNodeProps[], action: string) => {
    navigateTo: string | undefined;
};

declare const checkMicrophoneAccess: (handleMicToggle: Function, { requestDeniedMsg, notSupportedMsg, micAccessDeniedMsg, }: {
    requestDeniedMsg: string;
    notSupportedMsg: string;
    micAccessDeniedMsg: string;
}) => Promise<void>;

interface DebugToolsPanelProps {
    buttons?: string[];
    panelContentMap?: Record<string, React.ReactNode>;
    headerIconsMap?: Record<string, React.ReactNode>;
    headerLeadingIconMap?: Record<string, React.ReactNode>;
    panelheight?: string;
    panelwidth?: string;
}

declare const DebugToolsPanel: FC<DebugToolsPanelProps>;

interface SessionManagerProps {
    isRotate?: boolean;
    modal?: string[];
    onClick?: (index: number) => void;
    tooltip?: Record<string, string>;
    icons?: string[];
    className?: string;
}

declare const SessionManager: React$1.ForwardRefExoticComponent<SessionManagerProps & React$1.RefAttributes<HTMLDivElement>>;

declare const EMAIL_REGEX: RegExp;
declare const URL_REGEX: RegExp;
declare const PHONE_REGEX: RegExp;
declare const POSTAL_CODE_REGEX: RegExp;
declare const IPV4_REGEX: RegExp;
declare const IPV6_REGEX: RegExp;
declare const HEX_COLOR_REGEX: RegExp;
declare const PASSWORD_SIMPLE_REGEX: RegExp;
declare const PASSWORD_COMPLEX_REGEX: RegExp;
declare const ALPHABET_ONLY_REGEX: RegExp;
declare const NUMBERS_ONLY_REGEX: RegExp;
declare const ALPHANUMERIC_REGEX: RegExp;
declare const ALPHANUMERIC_WITH_ROUND_BRACES_REGEX: RegExp;
declare const DATE_REGEX: RegExp;
declare const TIME_REGEX: RegExp;
declare const FILE_EXTENSION_REGEX: RegExp;
declare const MAC_ADDRESS_REGEX: RegExp;
declare const CREDIT_CARD_REGEX: RegExp;
declare const SSN_REGEX: RegExp;
declare const UUID_REGEX: RegExp;
declare const HTML_TAG_REGEX: RegExp;
declare const WHITESPACE_REGEX: RegExp;
declare const US_ZIP_CODE_REGEX: RegExp;
declare const BIG_END_WHITESPACE: RegExp;
declare const USERNAME_REGEX: RegExp;
declare const INDIAN_PHONE_REGEX: RegExp;
declare const INDIAN_PIN_CODE_REGEX: RegExp;
declare const GSTIN_REGEX: RegExp;
declare const PAN_CARD_REGEX: RegExp;
declare const AADHAAR_REGEX: RegExp;
declare const VEHICLE_REGISTRATION_REGEX: RegExp;
declare const INDIAN_CURRENCY_REGEX: RegExp;
declare const INTERNATIONAL_PHONE_REGEX: RegExp;
declare const INDIAN_PASSPORT_REGEX: RegExp;
declare const DRIVING_LICENSE_REGEX: RegExp;
declare const USERNAME_SPECIAL_REGEX: RegExp;
declare const DECIMAL_NUMBER_REGEX: RegExp;
declare const HTML_ATTRIBUTE_REGEX: RegExp;
declare const RGB_COLOR_REGEX: RegExp;
declare const HSL_COLOR_REGEX: RegExp;
declare const BASE64_REGEX: RegExp;
declare const BINARY_NUMBER_REGEX: RegExp;
declare const HEXADECIMAL_NUMBER_REGEX: RegExp;
declare const ROMAN_NUMERALS_REGEX: RegExp;
declare const CURRENCY_GENERIC_REGEX: RegExp;
declare const LINKEDIN_PROFILE_REGEX: RegExp;
declare const TWITTER_HANDLE_REGEX: RegExp;
declare const NUMBER_REGEX: RegExp;
declare const UNIT_REGEX: RegExp;
declare const SCRIPT_REGEX: RegExp;
declare const MEMORY_VALIDATION_REGEX: RegExp;
declare const STEP_GROUP_NAME_REGEX: RegExp;
declare const NLP_DESCRIPTION_REGEX: RegExp;
declare const FILE_NAME_REGEX: RegExp;
declare const ELEMENTS_TRAILING_SPACE_REGEX: RegExp;
declare const ELEMENTS_WHITE_SPACE_REGEX: RegExp;
declare const PARAMETER_ALPHANUMERIC_REGEX: RegExp;
declare const ALPHANUMERIC_PARENTHESIS_REGEX: RegExp;
declare const CAMEL_CASE_REGEX: RegExp;
declare const DYNAMIC_VALUE__PLACEHOLDER_REGEX: RegExp;
declare const DYNAMIC_VALUE_PATTERN_REGEX: RegExp;
declare const DYNAMIC_VALUE_TYPE_REGEX: RegExp;
declare const DYNAMIC_VALUE_WITH_VALID_BRACKETS_REGEX: RegExp;
declare const CERTIFICATES_NAME_REGEX: RegExp;
declare const HTML_FILE_TYPE_VALIDATION: RegExp;
declare const BODY_TAG_TYPE_VALIDATION: RegExp;
declare const XML_FILE_TYPE_VALIDATION: RegExp;
declare const JAVASCRIPT_FILE_TYPE_VALIDATION: RegExp;
declare const CHECK_CAMEL_CASE: RegExp;
declare const START_END_WHITESPACE_REGEX: RegExp;
declare const ALPHA_NUM_REGEX: RegExp;
declare const EMAIL_VALIDATION_REGEX: RegExp;
declare const LINK_VALIDATION_REGEX: RegExp;
declare const ALPHA_NUM_EXTENDED_REGEX: RegExp;
declare const ALPHANUMERIC_WITH_DOT_REGEX: RegExp;
declare const EXCEL_SPACING_REGEX: RegExp;
declare const ALPHABET_WITH_SPACES_ONLY_REGEX: RegExp;

declare const setStoreValue: (key: string, value: string | object | null) => void;
declare const getStoreValue: (key: string) => string | unknown | null;
declare const deleteStoreValue: (key: string) => void;
declare const clearStore: () => void;

declare const convertToGB: (value: string) => number;

declare const convertToBytes: (value: string) => number;

interface StepResultStatsProps {
    metaData: any;
    width?: number;
}

declare const StepResultStats: React.FC<StepResultStatsProps>;

interface Action {
    text?: string;
    color?: string;
}
interface ScriptGenerationLoaderProps {
    /**
     * array
     */
    actions?: Action[];
    /**
     * In percentage
     */
    width?: number;
    /**
     * In percentage
     */
    height?: number;
    path?: string;
    DynamicHeight?: number;
}

declare const ScriptGenerationLoader: React__default.FC<ScriptGenerationLoaderProps>;

export { AADHAAR_REGEX, ALPHABET_ONLY_REGEX, ALPHABET_WITH_SPACES_ONLY_REGEX, ALPHANUMERIC_PARENTHESIS_REGEX, ALPHANUMERIC_REGEX, ALPHANUMERIC_WITH_DOT_REGEX, ALPHANUMERIC_WITH_ROUND_BRACES_REGEX, ALPHA_NUM_EXTENDED_REGEX, ALPHA_NUM_REGEX, Accordion, AddContentButton, AddResourceButton, AiToggle, AllProjectsDropdown, AnimatedSetting, AppHeader, AttachMedia, AttachmentButton, Avatar, BASE64_REGEX, BIG_END_WHITESPACE, BINARY_NUMBER_REGEX, BODY_TAG_TYPE_VALIDATION, BarChart, Card as Box, BrowserTabs, Button, CAMEL_CASE_REGEX, CERTIFICATES_NAME_REGEX, CHECK_CAMEL_CASE, CREDIT_CARD_REGEX, CURRENCY_GENERIC_REGEX, ChatModal, ChatModalAi, Checkbox, Chip, ChipWithCount, ChooseFile, Col, Comments, ConditionalDropdown, ConnectingBranch, Container, ContentCard, CreateVariableSlider, DATE_REGEX, DECIMAL_NUMBER_REGEX, DRIVING_LICENSE_REGEX, DYNAMIC_VALUE_PATTERN_REGEX, DYNAMIC_VALUE_TYPE_REGEX, DYNAMIC_VALUE_WITH_VALID_BRACKETS_REGEX, DYNAMIC_VALUE__PLACEHOLDER_REGEX, DashboardDonutChart, CustomDatePicker as DatePicker, DebugToolsPanel, DonutChart, DownloadClient, DragAndDrop, Drawer, Dropzone, ELEMENTS_TRAILING_SPACE_REGEX, ELEMENTS_WHITE_SPACE_REGEX, EMAIL_REGEX, EMAIL_VALIDATION_REGEX, EXCEL_SPACING_REGEX, EditLabel, EditTextField, Editor, ErrorBoundary, ExcelFile as Excel, ExpandableMenu, FILE_EXTENSION_REGEX, FILE_NAME_REGEX, FieldSet, FileDropzone, FilePreview, ForwardedForms as Form, formatString as FormatString, GSTIN_REGEX, HEXADECIMAL_NUMBER_REGEX, HEX_COLOR_REGEX, HSL_COLOR_REGEX, HTML_ATTRIBUTE_REGEX, HTML_FILE_TYPE_VALIDATION, HTML_TAG_REGEX, HighlightText, HistoryCard, INDIAN_CURRENCY_REGEX, INDIAN_PASSPORT_REGEX, INDIAN_PHONE_REGEX, INDIAN_PIN_CODE_REGEX, INTERNATIONAL_PHONE_REGEX, IPV4_REGEX, IPV6_REGEX, Icon, IconButton, IconRadialChart, IconRadioGroup, Input, InputWithDropdown, JAVASCRIPT_FILE_TYPE_VALIDATION, LINKEDIN_PROFILE_REGEX, LINK_VALIDATION_REGEX, LabelEditTextField, LineChart, LineLoader, Link, MAC_ADDRESS_REGEX, MEMORY_VALIDATION_REGEX, MachineInputField, MediaPreview, MediaViewerModal as MediaViewerModel, MenuOption, MessageBox, MiniModal, MobileSkin, Modal, ModuleChip, MultiRadialChart, MultiSelect, NlpInput as NLPInput, NLP_DESCRIPTION_REGEX, NUMBERS_ONLY_REGEX, NUMBER_REGEX, NoDataContent, OsTree, OtpVerification, OverviewModal, PAN_CARD_REGEX, PARAMETER_ALPHANUMERIC_REGEX, PASSWORD_COMPLEX_REGEX, PASSWORD_SIMPLE_REGEX, PHONE_REGEX, POSTAL_CODE_REGEX, Paper, PhoneInputField, PieChart, PopUpModal, PrePostTable, ProgressBar, Prompt, PromptContainer, RGB_COLOR_REGEX, ROMAN_NUMERALS_REGEX, RadialChart, RadioButton, RadioGroup, Recaptcha, Row, SCRIPT_REGEX, SSN_REGEX, START_END_WHITESPACE_REGEX, STEP_GROUP_NAME_REGEX, ScriptGenerationLoader, ScriptSwitchButton, Search, Select, SequentialConnectingBranch, SessionDropdown, SessionManager, StateDropdown, StatusButton, StatusCard, StatusIndicator, StepLandingTable, StepResultStats, SwitchButton, TIME_REGEX, TWITTER_HANDLE_REGEX, Table, TreeTable as TableTree, TableTreeFn, TableWithAccordion, Tabs, TabsWithSilder, Textarea as TextArea, TextEditor, ThemeProvider, Toaster, Toastify, Toggle, ToggleSwitch, Tooltip, TruncatedTooltip, Typography, UNIT_REGEX, URL_REGEX, USERNAME_REGEX, USERNAME_SPECIAL_REGEX, US_ZIP_CODE_REGEX, UUID_REGEX, VEHICLE_REGISTRATION_REGEX, VariableDropdown, VariableInput, VariableSuggestionInputDropDown, WHITESPACE_REGEX, XML_FILE_TYPE_VALIDATION, addPrePostStepGroup, addStepGroup, autoScrollToTableLastRow, capitalize, checkEmpty, checkMicrophoneAccess, clearStore, compareArrays, compareObjects, convertFormDataToObject, convertToBytes, convertToGB, convertToISO, debounce, deleteStoreValue, ffid, findAndInsert, formatDate, formatResponseDate, getEncryptedData, getExtension, getExtensionWithPeriod, getNavigateToKey, getSequentialPayload, getStoreValue, getTopVisibleNodeKey, getTreeDetails, handleTimeZoneChange, handleTreeExpandAllCollapseAll, handleTreeNodeExpandCollapse, handleTreeNodeSect, handleUnCheckAllTreeNodesWithUpdates, hasDuplicateFile, isEmptyObject, isTextTruncated, nlpInputDelay, rearrangeDragItem, saveFileFromBlob, scrollToView, setStoreValue, throttle, toCamelCase, toast, toggleShowHideEntity, truncateText, updateTreeState, useBeforeUnload, useClickOutside, useFileDropzone, useKeyboardActions, useTheme, useTriggerControl };
export type { RootNode$1 as RootNode, TreeNodeProps };