@oliasoft-open-source/react-ui-library 4.0.0-beta-40 → 4.0.0-beta-41

package/dist/index.d.ts

@@ -0,0 +1,1681 @@
+import { ChangeEvent } from 'react';
+import { CSSProperties } from 'react';
+import { DependencyList } from 'react';
+import { FocusEvent as FocusEvent_2 } from 'react';
+import { Id } from 'react-toastify';
+import { JSX as JSX_2 } from 'react/jsx-runtime';
+import { KeyboardEvent as KeyboardEvent_2 } from 'react';
+import { MouseEvent as MouseEvent_2 } from 'react';
+import { MouseEventHandler } from 'react';
+import { MutableRefObject } from 'react';
+import { Placement } from 'react-laag';
+import { Property } from 'csstype';
+import { default as React_2 } from 'react';
+import { ReactElement } from 'react';
+import { ReactNode } from 'react';
+import { ReactPortal } from 'react';
+import { RefObject } from 'react';
+import { ToastContainer as Toaster } from 'react-toastify';
+
+export declare const Accordion: ({ heading, expanded, managed, bordered, padding, children, onClick, squareBottom, testId, }: IAccordionProps) => JSX_2.Element;
+
+export declare const AccordionWithDefaultToggle: ({ heading, toggleLabel, onClickDefaultToggle, expanded, defaultEnabled, padding, children, }: IAccordionWithDefaultToggleProps) => JSX_2.Element;
+
+export declare const Actions: (props: IActionProps) => JSX_2.Element;
+
+export declare enum Align {
+    LEFT = "left",
+    RIGHT = "right",
+    CENTER = "center"
+}
+
+export declare const Badge: ({ children, color, title, dot, margin, small, }: IBadgeProps) => JSX_2.Element;
+
+export declare const Breadcrumb: ({ links, small }: IBreadcrumbProps) => JSX_2.Element;
+
+export declare enum BreadcrumbLinkType {
+    LABEL = "label",
+    LINK = "link",
+    CUSTOM = "custom"
+}
+
+export declare const Button: ({ active, basic, colored, disabled, groupOrder, icon, label, loading, name, pill, round, small, styles, width, title, type, onClick, error, warning, testId, tooltip, inverted, }: IButtonProps) => JSX_2.Element;
+
+export declare const ButtonGroup: (props: IButtonGroupProps) => JSX_2.Element;
+
+export declare enum ButtonPosition {
+    TOP = "top",
+    BOTTOM = "bottom"
+}
+
+export declare enum ButtonType {
+    SUBMIT = "submit",
+    BUTTON = "button",
+    RESET = "reset"
+}
+
+export declare const Card: ({ bordered, heading, children, margin, padding, raised, }: ICardProps) => JSX_2.Element;
+
+export declare const CheckBox: ({ noMargin, dataix, isInTable, tabIndex, checked, name, key, label, disabled, small, onChange, testId, value, helpText, onClickHelp, }: ICheckBoxProps) => JSX_2.Element;
+
+export declare enum Color {
+    DANGER = "danger",
+    RED = "red",
+    WHITE = "white",
+    SUCCESS = "success",
+    GREEN = "green",
+    MUTED = "muted"
+}
+
+export declare const Column: ({ background, borderLeft, borderRight, children, flex, flexbox, padding, scroll, showScrollbar, spacing, width, widthMobile, widthTablet, testId, }: ILayoutColumnProps) => JSX_2.Element;
+
+export declare const Dialog: ({ dialog }: IDialogProps) => JSX_2.Element;
+
+export declare const DisabledContext: React_2.Context<boolean>;
+
+export declare const Divider: ({ children, margin, color, align, }: IDividerProps) => JSX_2.Element;
+
+export declare const Drawer: ({ background, fixed, open: openProp, setOpen: setOpenProp, right, width, closedWidth, shadow, top, button, buttonAnimate, buttonPosition, border, children, tabs, defaultTabIndex, activeTab: activeTabProp, setActiveTab: setActiveTabProp, testId, onResize, getActiveTab, onClose, onOpen, }: IDrawerProps) => JSX_2.Element;
+
+export declare enum ElementType {
+    LINK = "Link",
+    BUTTON = "Button",
+    MENU = "Menu",
+    COMPONENT = "Component"
+}
+
+export declare const Empty: ({ width, height, text, children, testId, }: IEmptyProps) => JSX_2.Element;
+
+export declare const Field: ({ label, labelLeft, labelWidth, children, helpText, helpTextMaxWidth, onClickHelp, lock, info, libraryIcon, testId, }: IFieldProps) => JSX_2.Element;
+
+export declare const FileInput: ({ label, loading, placeholder, disabled, file, accept, multi, name, width, onChange, testId, }: IFileInputProps) => ReactElement;
+
+export declare const Flex: ({ alignItems, justifyContent, direction, height, children, wrap, gap, }: IFlexProps) => JSX_2.Element;
+
+export declare const FormRow: ({ children }: IFormRowProps) => JSX_2.Element;
+
+export declare const Grid: ({ rows, columns, columnsTablet, columnsMobile, gap, height, children, }: IGridProps) => JSX_2.Element;
+
+export declare enum GroupOrder {
+    FIRST = "first",
+    MIDDLE = "middle",
+    LAST = "last"
+}
+
+export declare const Heading: ({ children, helpText, onClick, onClickHelp, onIconClick, icon, libraryIcon, marginBottom, top, testId, }: IHeadingProps) => JSX_2.Element;
+
+export declare const HelpIcon: ({ text, onClick, icon, active, maxWidth, testId, }: IHelpIconProps) => JSX_2.Element;
+
+declare interface IAccordionBaseProps {
+    heading: ReactNode;
+    expanded?: boolean;
+    bordered?: boolean;
+    padding?: boolean;
+    children?: ReactNode;
+    squareBottom?: boolean;
+    onClick?: TEmpty;
+    testId?: string;
+}
+
+export declare interface IAccordionProps extends IAccordionBaseProps {
+    managed?: boolean;
+}
+
+export declare interface IAccordionWithDefaultToggleProps {
+    heading: ReactNode;
+    toggleLabel: string;
+    expanded?: boolean;
+    defaultEnabled?: boolean;
+    onClickDefaultToggle?: (evt: ChangeEvent<HTMLInputElement>) => void;
+    padding?: boolean;
+    children?: ReactNode;
+}
+
+declare interface IAction {
+    label?: TStringNumberNull;
+    childComponent?: ReactNode | (() => ReactNode);
+    subActions?: ISubAction[];
+    primary?: boolean;
+    icon?: ReactNode;
+    testId?: string;
+    hidden?: boolean;
+    disabled?: boolean;
+    onClick?: (evt: React_2.MouseEvent, id?: TStringOrNumber) => void;
+    tooltip?: ReactNode | string;
+}
+
+declare interface IActionCell extends TCommonCell {
+    type: TCellType;
+    actions: any;
+}
+
+export declare interface IActionProps {
+    actions: IAction[];
+    closeLayer?: TEmpty;
+}
+
+export declare interface IBadgeProps {
+    children?: ReactNode;
+    color?: string;
+    title?: TStringOrNumber | null;
+    dot?: boolean;
+    margin?: TStringOrNumber | null;
+    small?: boolean;
+}
+
+export declare interface IBreadcrumbProps {
+    links: ILinkProps[];
+    small?: boolean;
+}
+
+declare interface IBtnGroupItemProps {
+    label?: string | null;
+    value?: string;
+    key?: TStringOrNumber;
+    hidden?: boolean;
+    icon?: any;
+    error?: any;
+    maxTooltipWidth?: any;
+    testId?: string;
+    tooltip?: any;
+    warning?: any;
+    disabled?: boolean;
+}
+
+export declare interface IButtonGroupProps {
+    disabled?: boolean;
+    basic?: boolean;
+    items?: string[] | (string[] | IBtnGroupItemProps)[];
+    header?: string;
+    onSelected?: TFunction;
+    small?: boolean;
+    value?: TStringOrNumber;
+    testId?: string;
+}
+
+export declare interface IButtonProps {
+    active?: boolean;
+    basic?: boolean;
+    colored?: boolean | string;
+    disabled?: boolean;
+    groupOrder?: string | null;
+    icon?: ReactNode | string;
+    label?: ReactNode | string | null;
+    loading?: boolean;
+    name?: string | null;
+    onClick?: (evt: MouseEvent_2<HTMLButtonElement>) => void;
+    pill?: boolean;
+    round?: boolean;
+    small?: boolean;
+    styles?: string;
+    width?: TStringOrNumber;
+    title?: string;
+    type?: TButtonType | string;
+    error?: string;
+    warning?: string;
+    testId?: string;
+    tooltip?: ReactNode | string;
+    inverted?: boolean;
+}
+
+export declare interface ICardProps {
+    bordered?: boolean;
+    heading?: ReactNode;
+    margin?: string;
+    padding?: boolean;
+    raised?: boolean;
+    children?: ReactNode;
+}
+
+declare interface ICheckBoxCell extends TCommonCell {
+    label?: string | null;
+    checked: boolean;
+    type: TCellType;
+    onChange: (ev: React_2.ChangeEvent<HTMLInputElement>) => void;
+    disabled?: boolean;
+}
+
+export declare interface ICheckBoxProps {
+    checked?: boolean;
+    isInTable?: boolean;
+    label?: string | null;
+    name?: string;
+    noMargin?: boolean;
+    onChange: (evt: React_2.ChangeEvent<HTMLInputElement>) => void;
+    tabIndex?: number;
+    disabled?: boolean;
+    small?: boolean;
+    testId?: string;
+    key?: string;
+    dataix?: number;
+    value?: string;
+    helpText?: string;
+    onClickHelp?: TEmpty;
+}
+
+/**
+ * Icon wrapper component to support different icon formats:
+ *     - string names (default recommendation)
+ *     - react-icons
+ *     - SVG (for special cases)
+ */
+export declare const Icon: ({ icon, onClick, clickable, color, size, testId, }: IconProps) => JSX_2.Element;
+
+export declare interface IconProps {
+    icon: ReactNode | string;
+    onClick?: MouseEventHandler<HTMLDivElement>;
+    clickable?: boolean;
+    color?: string;
+    size?: TStringOrNumber;
+    testId?: string;
+}
+
+export declare enum IconType {
+    LIBRARY = "library",
+    ADD = "add",
+    DRAG = "drag",
+    DRAG_HORIZONTAL = "drag horizontal",
+    HELP = "help",
+    NOTIFICATION = "notification",
+    MENU = "menu",
+    EDIT = "edit",
+    FAST_FORWARD = "fast forward",
+    INDENT = "indent",
+    STAR = "star",
+    LIST = "list",
+    SETTINGS = "settings",
+    CHECK = "check",
+    LOCK = "lock",
+    UNLOCK = "unlock",
+    CLOSE = "close",
+    SUCCESS = "success",
+    WARNING = "warning",
+    ERROR = "error",
+    INFO = "info",
+    LEFT = "left",
+    COLLAPSE = "collapse",
+    EXPAND = "expand",
+    SORT_ASCENDING = "sort ascending",
+    SORT_DESCENDING = "sort descending",
+    FAST_BACKWARD = "fast backward",
+    CHEVRON_DOWN = "chevron down",
+    CHEVRON_RIGHT = "chevron right",
+    CHEVRON_LEFT = "chevron left",
+    CHEVRON_DOUBLE_LEFT = "chevron double left",
+    CHEVRON_DOUBLE_RIGHT = "chevron double right"
+}
+
+declare interface IDialog {
+    heading?: string | null;
+    content?: ReactNode | string[];
+    contentPadding?: number | string;
+    footer?: ReactNode;
+    width?: number | string;
+    height?: number | string;
+    bordered?: boolean;
+    onClose?: TEmpty;
+    scroll?: boolean;
+    testId?: string;
+}
+
+export declare interface IDialogProps {
+    dialog: IDialog;
+}
+
+export declare interface IDividerProps {
+    margin?: number | string;
+    color?: string;
+    align?: TAlign | string;
+    children?: React_2.ReactNode;
+}
+
+export declare interface IDrawerProps {
+    background?: string;
+    children?: ReactNode;
+    fixed?: boolean;
+    open?: boolean;
+    setOpen?: (openState: boolean) => void;
+    right?: boolean;
+    shadow?: boolean;
+    top?: TStringOrNumber;
+    width?: TStringOrNumber | Array<TStringOrNumber>;
+    closedWidth?: TStringOrNumber;
+    button?: boolean | ReactNode;
+    buttonAnimate?: boolean;
+    buttonPosition?: TButtonPosition | string;
+    border?: boolean | string;
+    tabs?: IDrawerTab[];
+    defaultTabIndex?: number;
+    activeTab?: number;
+    setActiveTab?: (index: number) => void;
+    testId?: string;
+    onResize?: TFunction;
+    getActiveTab?: (tab: IDrawerTab) => void;
+    onClose?: (tab?: IDrawerTab) => any;
+    onOpen?: (tab?: IDrawerTab) => any;
+}
+
+declare interface IDrawerTab {
+    icon?: ReactNode | React_2.JSX.Element;
+    content?: ReactNode;
+    badge?: TStringOrNumber;
+}
+
+export declare interface IEmptyProps {
+    width?: TStringOrNumber;
+    height?: TStringOrNumber;
+    text?: string | ReactNode;
+    children?: ReactNode;
+    testId?: string;
+}
+
+export declare interface IFieldProps {
+    label?: TStringNumberNull | ReactNode;
+    labelLeft?: boolean;
+    labelWidth?: TStringOrNumber;
+    children: ReactNode;
+    helpText?: TStringOrNumber | ReactNode;
+    helpTextMaxWidth?: TStringOrNumber;
+    onClickHelp?: (event?: MouseEvent_2<HTMLDivElement>) => void;
+    lock?: ILabelLockProps;
+    info?: string;
+    libraryIcon?: ILabelIcon;
+    testId?: string;
+}
+
+export declare interface IFileInputProps {
+    label?: string | null;
+    loading?: boolean;
+    placeholder?: string;
+    disabled?: boolean;
+    file?: File;
+    accept?: string;
+    multi?: boolean;
+    name?: string;
+    width?: TStringOrNumber;
+    onChange?: (evt: any) => void;
+    testId?: string;
+}
+
+export declare interface IFlexProps {
+    alignItems?: string;
+    justifyContent?: string;
+    direction?: Property.FlexDirection;
+    height?: TStringOrNumber;
+    children?: React_2.ReactNode;
+    wrap?: boolean;
+    gap?: boolean | TStringOrNumber;
+}
+
+declare interface IFooterProps {
+    colSpan?: number;
+    pagination: IPagination;
+    actions?: IAction[];
+    content?: ReactNode;
+}
+
+export declare interface IFormRowProps {
+    children?: ReactNode;
+}
+
+export declare interface IGridProps {
+    rows?: string;
+    columns?: string;
+    columnsTablet?: string | null;
+    columnsMobile?: string | null;
+    gap?: boolean | TStringOrNumber;
+    height?: TStringOrNumber;
+    children?: ReactNode;
+}
+
+export declare interface IHeadingProps {
+    children: ReactNode;
+    helpText?: string;
+    onClick?: (evt: MouseEvent_2<HTMLDivElement>) => void;
+    onClickHelp?: TEmpty;
+    onIconClick?: TEmpty;
+    icon?: ReactNode;
+    libraryIcon?: ILibraryIconProps;
+    marginBottom?: TStringOrNumber;
+    top?: boolean;
+    testId?: string;
+}
+
+declare interface IHelpIconCell extends TCommonCell {
+    type: TCellType;
+    helpIcon?: {
+        onClick: TEmpty;
+        tooltip: StringNumberOrNode;
+    };
+}
+
+export declare interface IHelpIconProps {
+    text?: TStringOrNumber | ReactNode;
+    onClick?: (event?: MouseEvent_2<HTMLDivElement>) => void;
+    icon?: ReactNode;
+    active?: boolean;
+    maxWidth?: TStringOrNumber;
+    testId?: string;
+}
+
+declare interface IIconCell extends TCommonCell {
+    type: TCellType;
+    icon: any;
+    tooltip?: StringNumberOrNode;
+}
+
+declare interface IInputCell extends TCommonCell {
+    type: TCellType;
+    name?: string;
+    value?: TStringOrNumber;
+    onChange?: (ev: React_2.ChangeEvent<HTMLInputElement>) => void;
+    onPaste?: React_2.ClipboardEventHandler<HTMLInputElement>;
+    placeholder?: string;
+    error?: string;
+    warning?: string;
+    disabled?: boolean;
+    maxTooltipWidth?: TStringOrNumber;
+    tooltip?: StringNumberOrNode;
+}
+
+export declare interface IInputGroupAddonProps {
+    children: ReactNode;
+    groupOrder?: TGroupOrder | string | null;
+    small?: boolean;
+}
+
+export declare interface IInputGroupProps {
+    children: ReactNode;
+    small?: boolean;
+    width?: TStringOrNumber;
+}
+
+export declare interface IInputProps {
+    error?: TStringOrNumber | React_2.ReactNode;
+    warning?: TStringOrNumber | React_2.ReactNode;
+    tooltip?: TStringOrNumber | React_2.ReactNode;
+    name?: string;
+    type?: string;
+    onChange?: React_2.ChangeEventHandler<HTMLInputElement>;
+    onKeyPress?: React_2.KeyboardEventHandler<HTMLInputElement>;
+    onFocus?: React_2.FocusEventHandler<HTMLInputElement>;
+    onBlur?: React_2.FocusEventHandler<HTMLInputElement>;
+    onPaste?: React_2.ClipboardEventHandler<HTMLInputElement>;
+    small?: boolean;
+    placeholder?: string | null;
+    tabIndex?: number;
+    value?: TStringNumberNull;
+    disabled?: boolean;
+    right?: boolean;
+    groupOrder?: string;
+    maxTooltipWidth?: TStringOrNumber;
+    width?: TStringOrNumber;
+    testId?: string;
+    size?: number;
+    isInTable?: boolean;
+}
+
+declare interface ILabel {
+    color: string;
+    value: string;
+}
+
+declare interface ILabelIcon {
+    onClick: TEmpty;
+    tooltip?: string;
+}
+
+declare interface ILabelLockProps {
+    visible?: boolean;
+    active?: boolean;
+    onClick?: TEmpty;
+    tooltip?: string;
+    testId?: string;
+}
+
+export declare interface ILabelProps {
+    label?: TStringNumberNull | ReactNode;
+    helpText?: TStringOrNumber | ReactNode;
+    helpTextMaxWidth?: TStringOrNumber;
+    width?: TStringOrNumber;
+    info?: string;
+    onClickHelp?: (event?: MouseEvent_2<HTMLDivElement>) => void;
+    lock?: ILabelLockProps;
+    libraryIcon?: ILabelIcon;
+    labelLeft?: boolean;
+}
+
+export declare interface ILayoutColumnProps {
+    background?: string;
+    borderLeft?: boolean | string;
+    borderRight?: boolean | string;
+    children?: React_2.ReactNode;
+    flex?: boolean;
+    flexbox?: boolean;
+    padding?: boolean | string;
+    scroll?: boolean;
+    showScrollbar?: boolean;
+    spacing?: number | string;
+    width?: number | string;
+    widthMobile?: number | string;
+    widthTablet?: number | string;
+    testId?: string;
+}
+
+export declare interface ILayoutPageProps {
+    children?: ReactNode;
+    padding?: boolean | TStringOrNumber;
+    left?: TStringOrNumber;
+    scroll?: boolean;
+    top?: TStringOrNumber;
+}
+
+declare interface ILibraryIconCell extends TCommonCell {
+    type: TCellType;
+    libraryIcon?: {
+        onClick: TEmpty;
+        tooltip: StringNumberOrNode;
+    };
+}
+
+declare interface ILibraryIconProps {
+    onClick: TEmpty;
+    tooltip?: string;
+}
+
+declare interface ILinkCell extends TCommonCell {
+    value?: TStringOrNumber;
+    type: TCellType;
+    disabled?: boolean;
+    onClick?: (evt: React_2.MouseEvent<HTMLAnchorElement, MouseEvent>) => void;
+    error?: StringNumberOrNode;
+    warning?: StringNumberOrNode;
+    tooltip?: StringNumberOrNode;
+    maxTooltipWidth?: TStringOrNumber;
+}
+
+declare interface ILinkProps {
+    type?: TBreadcrumbLinkType | string;
+    label?: TStringNumberNull;
+    url?: string;
+    onClick?: TEmpty;
+    active?: boolean;
+    disabled?: boolean;
+    element?: ReactNode;
+}
+
+declare interface IListAction {
+    label: string;
+    icon?: ReactNode;
+    onClick?: TEmpty;
+    primary?: boolean;
+    subActions?: ISubAction_2[];
+    childComponent?: ReactNode;
+}
+
+declare interface IListData {
+    name?: ReactNode | string;
+    actions?: IListAction[];
+    items: IListItem[];
+}
+
+export declare interface IListHeadingProps {
+    name: TStringOrNumber | ReactNode;
+    actions?: any[];
+    toggleNarrow?: boolean;
+    onToggleNarrow?: TEmpty;
+    stickyHeader?: boolean;
+}
+
+declare interface IListItem {
+    name?: string | ReactElement;
+    expanded?: boolean;
+    cursor?: string;
+    url?: string;
+    active?: boolean;
+    disabled?: boolean;
+    onClick?: (evt: any) => void;
+    title?: string;
+    testId?: string;
+    level?: number;
+    label?: ILabel;
+    actions?: IAction[];
+    id?: TStringOrNumber;
+    type?: string;
+    metaCount?: number;
+}
+
+export declare interface IListProps {
+    drawer?: boolean;
+    list: IListData;
+    bordered?: boolean;
+    expanding?: boolean;
+    narrow?: boolean;
+    toggleNarrow?: boolean;
+    onToggleNarrow?: TEmpty;
+    invokeEditOnRowClick?: boolean;
+    noHeader?: boolean;
+    stickyHeader?: boolean;
+    draggable?: boolean;
+    onListReorder?: (args: IReorderData) => void;
+    marginBottom?: number | string;
+    height?: number | string;
+    testId?: string;
+    scrollDetails?: IScrollDetails;
+}
+
+declare interface IListSubheadingItem extends Partial<IMetaContentItem> {
+    actions?: IAction[];
+    disabled?: boolean;
+    expanded?: boolean;
+    onClick?: (evt: MouseEvent_2<HTMLDivElement>) => void;
+    title?: string;
+    testId?: string;
+    metaCount?: number;
+}
+
+export declare interface IListSubheadingProps {
+    item: IListSubheadingItem;
+    index?: number;
+}
+
+export declare interface ILoaderProps {
+    fullViewPortSize?: boolean;
+    cover?: boolean;
+    width?: TStringOrNumber;
+    height?: TStringOrNumber;
+    text?: string;
+    details?: string | ReactNode;
+    children?: ReactNode;
+    testId?: string | null;
+    theme?: TTheme | string;
+}
+
+export declare interface IMenuProps {
+    menu: {
+        trigger: TTriggerType | string;
+        title?: string;
+        colored?: boolean | string;
+        small?: boolean;
+        label?: ReactNode | string;
+        component?: ReactNode;
+        sections?: ReactNode | IMenuSection[];
+        placement?: string;
+        possiblePlacements?: Placement[];
+        showAllButton?: IMenuShowAllButton;
+        testId?: string;
+        fullHeightTrigger?: boolean;
+    };
+    contextMenu?: boolean;
+    width?: TStringOrNumber;
+    disabled?: boolean;
+    badgeTitle?: string;
+    badgeDot?: boolean;
+    loading?: boolean;
+    fullHeightTrigger?: boolean;
+    closeOnOptionClick?: boolean;
+    groupOrder?: TGroupOrder | string;
+    overflowContainer?: boolean;
+    maxHeight?: TStringOrNumber;
+    testId?: string;
+    open?: boolean;
+    setOpen?: (state: boolean) => void;
+    closeParent?: TEmpty;
+    tree?: any;
+    path?: any;
+    isNested?: boolean;
+    tooltip?: any;
+    error?: any;
+    warning?: any;
+    title?: string;
+}
+
+declare interface IMenuSection {
+    type: TMenuType | string;
+    label?: TStringNumberNull;
+    icon?: string | ReactNode;
+    onClick?: TFunction;
+    testId?: string;
+    description?: string;
+    selected?: boolean;
+    disabled?: boolean;
+    inline?: boolean;
+    title?: string;
+    download?: boolean;
+    onChange?: TFunction;
+    menu?: any;
+    visible?: boolean;
+    closeOnOptionClick?: boolean;
+    actions?: any[];
+    url?: string;
+    upload?: boolean;
+}
+
+declare interface IMenuShowAllButton {
+    visible: boolean;
+    showAllTitle: string;
+    showLessTitle: string;
+    additionalSections: IMenuSection[];
+}
+
+declare interface IMessage {
+    visible?: boolean;
+    type?: TMessageType | string;
+    icon?: boolean;
+    heading?: ReactNode;
+    content?: ReactNode | string;
+    details?: ReactNode;
+    footer?: ReactNode;
+    withDismiss?: boolean;
+    onClose?: (evt: MouseEvent_2<SVGSVGElement>) => void;
+    width?: TStringOrNumber;
+    maxHeight?: TStringOrNumber;
+}
+
+export declare interface IMessageProps {
+    message: IMessage;
+}
+
+declare type IMessageType = {
+    type?: TMessageType | string;
+    icon?: boolean;
+    heading?: string | number;
+    content: ReactNode | string;
+    details?: ReactNode | string | null;
+};
+
+declare interface IMetaContentItem {
+    name?: TStringOrNumber | ReactNode;
+    icon?: {
+        icon: ReactNode;
+        color?: string;
+        tooltip?: {
+            text: string | ReactNode;
+        };
+    };
+    details?: string | ReactNode;
+    metadata?: string | ReactNode;
+    invalid?: boolean;
+    testId?: string;
+}
+
+export declare interface IModalProps {
+    children: ReactNode;
+    visible?: boolean;
+    centered?: boolean;
+    width?: TStringOrNumber;
+}
+
+export declare interface INativeSelectProps {
+    borderRadius?: TStringOrNumber;
+    disabled?: boolean;
+    error?: TStringOrNumber | React_2.ReactNode | null;
+    warning?: TStringOrNumber | React_2.ReactNode | null;
+    tooltip?: TStringOrNumber | React_2.ReactNode | null;
+    options: ISelectSelectedOption[];
+    onChange?: (evt: ChangeEvent<HTMLSelectElement>, value: ISelectSelectedOption | {
+        value: null;
+    }) => void;
+    onFocus?: TEmpty;
+    onBlur?: TEmpty;
+    right?: boolean;
+    small?: boolean;
+    tabIndex?: number;
+    selectedOption?: ISelectSelectedOption;
+    width?: TStringOrNumber | null;
+    groupOrder?: string | null;
+    testId?: string | undefined;
+    isInTable?: boolean;
+    clearable?: boolean;
+    placeholder?: string | null;
+    hasNonExistentValue?: boolean;
+    maxTooltipWidth?: TStringOrNumber;
+}
+
+export declare const Input: React_2.ForwardRefExoticComponent<IInputProps & React_2.RefAttributes<HTMLInputElement>>;
+
+export declare const InputGroup: ({ children, small, width, }: IInputGroupProps) => ReactElement;
+
+export declare const InputGroupAddon: ({ children, groupOrder, small, }: IInputGroupAddonProps) => React_2.ReactElement;
+
+export declare enum InputReaderMethods {
+    READ_AS_TEXT = "readAsText",
+    READ_AS_ARRAY_BUFFER = "readAsArrayBuffer",
+    READ_AS_DATA_URL = "readAsDataURL",
+    READ_AS_BINARY_STRING = "readAsBinaryString"
+}
+
+export declare enum InputType {
+    TEXT = "text",
+    RADIO = "radio",
+    CHECKBOX = "checkbox"
+}
+
+declare interface INumberInputCell extends TCommonCell {
+    name?: string;
+    value?: TStringOrNumber;
+    type: TCellType;
+    onChange?: (ev: any) => void;
+    placeholder?: string;
+    error?: string | boolean;
+    warning?: string | boolean;
+    disabled?: boolean;
+    tooltip?: StringNumberOrNode;
+    left?: boolean;
+    validationCallback?: TEmpty;
+    allowEmpty?: boolean;
+}
+
+export declare interface INumberInputProps {
+    name?: string | {
+        fieldName: string;
+    };
+    placeholder?: string;
+    disabled?: boolean;
+    error?: string | boolean;
+    left?: boolean;
+    small?: boolean;
+    width?: TStringOrNumber;
+    value?: TStringOrNumber;
+    onChange?: (evt: ChangeEvent<HTMLInputElement>) => void;
+    onFocus?: (evt: FocusEvent_2<HTMLInputElement>) => void;
+    tabIndex?: number;
+    testId?: string;
+    tooltip?: TStringOrNumber | React_2.ReactNode;
+    warning?: string | boolean;
+    validationCallback?: (name: string | {
+        fieldName: string;
+    }, error: string | null) => void;
+    allowEmpty?: boolean;
+    isInTable?: boolean;
+    groupOrder?: any;
+}
+
+export declare interface IOptionDropdownProps {
+    name?: string;
+    label: string;
+    options: IOptionType[];
+    onChange: (evt: ChangeEvent<HTMLInputElement & {
+        name?: string;
+        value: IOptionType[];
+    }>) => void;
+    showHeader?: boolean;
+    maxHeight?: string;
+}
+
+declare interface IOptionItem {
+    label: ReactNode;
+    value: string;
+    icon: ReactNode;
+    onClick: (evt: MouseEvent_2<HTMLAnchorElement, globalThis.MouseEvent>) => void;
+    isActive?: boolean;
+    isExperimental?: boolean;
+    invalid?: boolean;
+    testId?: string;
+}
+
+declare interface IOptionSection {
+    heading: string;
+    items: IOptionItem[];
+}
+
+declare interface IOptionType {
+    label?: string | null;
+    value?: TStringOrNumber;
+    selected?: boolean;
+}
+
+declare interface IPagination {
+    rowCount: number;
+    selectedPage: TStringOrNumber;
+    onSelectPage?: (value: number) => void;
+    rowsPerPage?: IPaginationPerPageType;
+    small?: boolean;
+    errorMessageTemplate?: string;
+}
+
+declare interface IPaginationOptionType {
+    label?: string | null;
+    value?: TStringOrNumber;
+    selected?: boolean;
+}
+
+declare interface IPaginationPerPageType {
+    onChange?: (evt: React_2.ChangeEvent<HTMLInputElement>) => void;
+    options?: IPaginationOptionType[];
+    value?: TStringOrNumber;
+}
+
+export declare interface IPaginationProps {
+    pagination: IPagination;
+}
+
+export declare interface IPopConfirmProps {
+    children?: ReactNode;
+    placement?: Placement;
+    closeOnOutsideClick?: boolean;
+    fullWidth?: boolean;
+    title?: string;
+    cancelText?: string;
+    onClickCancel?: (close?: TEmpty) => void;
+    okText?: string;
+    onClickOk?: (close?: TEmpty) => void;
+    overflowContainer?: boolean;
+    testId?: string;
+}
+
+declare interface IPopoverCell extends TCommonCell {
+    content: React_2.ReactNode;
+    fullWidth: boolean;
+    closeOnOutsideClick: boolean;
+    disabled: boolean;
+    value?: StringNumberOrNode;
+    type: TCellType;
+    error?: StringNumberOrNode;
+    warning?: StringNumberOrNode;
+    tooltip?: StringNumberOrNode;
+    maxTooltipWidth?: TStringOrNumber;
+    hasSort?: boolean;
+}
+
+export declare interface IPopoverProps {
+    children?: ReactNode;
+    content?: ReactNode;
+    placement?: Placement;
+    closeOnOutsideClick?: boolean;
+    fullWidth?: boolean;
+    showCloseButton?: boolean;
+    testId?: string;
+    disabled?: boolean;
+    overflowContainer?: boolean;
+}
+
+export declare interface IPortalProps {
+    id: string;
+    children: ReactNode | any;
+}
+
+export declare interface IPrintHeaderProps {
+    logo: string;
+    logoWidth?: TStringOrNumber;
+    alt: string;
+}
+
+export declare interface IProgressBarProps {
+    width?: TStringOrNumber;
+    inverted?: boolean;
+    colored?: boolean;
+    showProgressColors?: boolean;
+    percentage?: number;
+    noLabel?: boolean;
+}
+
+declare interface IRadioButtonOption {
+    label: TStringOrNumber;
+    value: TStringOrNumber;
+    testId?: string;
+    helpText?: string;
+    onClickHelp?: (evt: MouseEvent_2<HTMLButtonElement>) => void;
+    name?: string;
+    checked?: boolean;
+    disabled?: boolean;
+}
+
+export declare interface IRadioButtonProps {
+    name?: string;
+    label?: string | null;
+    options: IRadioButtonOption[];
+    value: TStringOrNumber | IRadioButtonOption;
+    inline?: boolean;
+    disabled?: boolean;
+    small?: boolean;
+    onChange?: (evt: ChangeEvent<HTMLInputElement>) => void;
+    noMargin?: boolean;
+    mainLabel?: string;
+    onClick?: (target: HTMLInputElement) => void;
+    radioButtonsData?: IRadioButtonOption[];
+    classForContainer?: 'grouped fields' | 'inline fields';
+}
+
+declare interface IReorderData {
+    from?: number;
+    to?: number;
+}
+
+export declare interface IRichTextInputProps {
+    disabled?: boolean;
+    onChange?: (markdown: string) => void;
+    placeholder?: string;
+    value?: string;
+    toolbarComponent?: ReactNode;
+}
+
+export declare interface IRowProps {
+    alignItems?: CSSProperties['alignItems'];
+    justifyContent?: CSSProperties['justifyContent'];
+    children?: ReactNode;
+    flex?: boolean;
+    height?: TStringOrNumber;
+    marginBottom?: TStringOrNumber;
+    marginTop?: TStringOrNumber;
+    spacing?: TStringOrNumber;
+    wrap?: boolean;
+    testId?: string | null;
+}
+
+declare interface IScrollDetails {
+    scrollable?: boolean;
+    hideScrollbar?: boolean;
+    triggerScrollToActiveItem?: boolean;
+    infiniteScroll?: boolean;
+    infiniteScrollTarget?: string;
+    limit?: number;
+}
+
+declare interface ISelectCell extends TCommonCell {
+    type: TCellType;
+    name?: string;
+    value?: TStringOrNumber;
+    onChange?: (ev: any) => void;
+    onCreate?: (ev: any) => void;
+    error?: StringNumberOrNode;
+    warning?: StringNumberOrNode;
+    disabled?: boolean;
+    placeholder?: string;
+    menu?: any;
+    options?: any;
+    native?: boolean;
+    clearable?: boolean;
+    searchable?: boolean;
+    deprecatedEventHandler?: boolean;
+    maxTooltipWidth?: TStringOrNumber;
+    autoLayerWidth?: boolean;
+}
+
+export declare interface ISelectProps {
+    name?: string;
+    multi?: boolean;
+    options?: ISelectSelectedOption[];
+    value?: any;
+    native?: boolean;
+    onChange?: (value: any) => void;
+    deprecatedEventHandler?: boolean;
+    autoScroll?: boolean;
+    warning?: TStringOrNumber | ReactNode;
+    error?: TStringOrNumber | ReactNode;
+    checkNonExistentValues?: boolean;
+    closeOnOptionActionClick?: boolean;
+    small?: boolean;
+    width?: TStringOrNumber | null;
+    borderRadius?: TStringOrNumber;
+    onCreate?: (evt: any) => any;
+    disabled?: boolean;
+    placeholder?: string | null;
+    isInTable?: boolean;
+    clearable?: boolean;
+    searchable?: boolean;
+    maxTooltipWidth?: TStringOrNumber;
+    autoLayerWidth?: boolean;
+    right?: boolean;
+    tabIndex?: number;
+    testId?: string;
+}
+
+declare interface ISelectSelectedOption {
+    value?: TStringNumberNull | boolean;
+    label?: string | ReactNode;
+    details?: string;
+    actions?: any[];
+    icon?: boolean | ReactNode;
+    type?: string;
+    disabled?: boolean;
+    testId?: string;
+}
+
+export declare interface ISideBarProps {
+    options: {
+        title: string;
+        sections: IOptionSection[];
+    };
+    startOpen?: boolean;
+    onShiftClickToggleOpen?: (evt: MouseEvent_2<HTMLButtonElement, globalThis.MouseEvent>) => void;
+    top?: TStringOrNumber;
+}
+
+declare interface ISimpleCell extends TCommonCell {
+    value: TStringOrNumber | ReactNode;
+    type?: TCellType;
+}
+
+declare interface ISliderCell extends TCommonCell {
+    type: TCellType;
+    label?: string | null;
+    value: number;
+    min: number;
+    max: number;
+    step?: number;
+    marks?: TSliderMark[];
+    onChange: (ev: any) => void;
+    showArrows?: boolean;
+    showTooltip?: boolean;
+    tooltipFormatter?: (value: any) => any;
+    disabled?: boolean;
+}
+
+export declare interface ISliderProps {
+    name?: string;
+    label?: TStringNumberNull | ReactNode;
+    width?: TStringOrNumber;
+    labelWidth?: TStringOrNumber;
+    value: number | number[];
+    min: number;
+    max: number;
+    step?: number;
+    marks?: TSliderMark[];
+    showArrows?: boolean;
+    showTooltip?: boolean;
+    tooltipFormatter?: (value: number | number[]) => TStringOrNumber | ReactNode;
+    disabled?: boolean;
+    range?: boolean;
+    small?: boolean;
+    vertical?: {
+        enabled: boolean;
+        width?: string;
+        height?: string;
+    };
+    onChange: (evt: {
+        target: {
+            name?: string;
+            value: number | number[];
+            label?: TStringNumberNull | ReactNode;
+        };
+    }) => void;
+}
+
+declare interface ISortCell extends TCommonCell {
+    type: TCellType;
+    hasSort?: boolean;
+    sort?: 'up' | 'down';
+    sortPriority?: number;
+}
+
+export declare interface ISpacerProps {
+    height?: TStringOrNumber;
+    width?: TStringNumberNull;
+    flex?: boolean;
+}
+
+export declare interface ISpinnerProps {
+    small?: boolean;
+    colored?: boolean;
+    dark?: boolean;
+    tiny?: boolean;
+}
+
+declare interface IStaticCell extends TCommonCell {
+    value?: StringNumberOrNode;
+    type: TCellType;
+    error?: StringNumberOrNode;
+    warning?: StringNumberOrNode;
+    tooltip?: StringNumberOrNode;
+    maxTooltipWidth?: TStringOrNumber;
+    breakWord?: boolean;
+    libraryIcon?: {
+        onClick: TEmpty;
+        tooltip: StringNumberOrNode;
+    };
+    helpIcon?: {
+        onClick: TEmpty;
+        tooltip: StringNumberOrNode;
+    };
+    hasSort?: boolean;
+    onSort?: (evt: React_2.MouseEvent<HTMLDivElement>) => void;
+}
+
+declare interface ISubAction {
+    label?: TStringNumberNull;
+    icon?: ReactNode;
+    onClick: TFunction;
+    testId?: string;
+    disabled?: boolean;
+}
+
+declare interface ISubAction_2 {
+    label: string;
+    icon: ReactNode;
+    onClick: TEmpty;
+}
+
+export declare interface ITableProps {
+    onListReorder?: (obj: {
+        from: number;
+        to: number;
+    }) => void;
+    table: {
+        name?: TStringOrNumber | ReactNode;
+        actionsRight?: boolean;
+        fixedWidth?: TStringOrNumber;
+        maxHeight?: TStringOrNumber;
+        columnWidths?: string[];
+        className?: string;
+        columnHeaderAlignments?: Array<TAlign | string>;
+        columnAlignment?: Array<TAlign | string>;
+        infiniteScroll?: boolean;
+        headers?: any[];
+        rows?: TRowsType;
+        footer?: IFooterProps;
+        draggable?: boolean;
+        bordered?: boolean;
+        striped?: boolean;
+        testId?: string;
+        onAddRow?: any;
+        defaultEmptyRow?: any;
+        stickyHeaders?: string | boolean;
+        actions?: any;
+    };
+}
+
+declare interface ITabOption {
+    key?: string;
+    label: TStringOrNumber;
+    value: TStringOrNumber;
+    url?: string;
+    hidden?: boolean;
+    disabled?: boolean;
+    invalid?: boolean;
+    badge?: TStringOrNumber;
+    right?: boolean;
+    testId?: string;
+}
+
+declare interface ITabSelectedOption {
+    label: TStringOrNumber;
+    value: TStringOrNumber;
+}
+
+export declare interface ITabsProps {
+    name?: string;
+    options?: ITabOption[] | null;
+    children?: any;
+    value?: ITabSelectedOption;
+    onChange?: (evt: ChangeEvent<any>) => void;
+    padding?: boolean;
+    margin?: boolean;
+    contentPadding?: boolean;
+    activeTabIndex?: number;
+    tabs?: ITabOption[] | undefined;
+    onChangeTab?: (index: number, value: TStringOrNumber | null) => void;
+    testId?: string;
+}
+
+export declare interface ITextAreaProps {
+    name?: string;
+    value?: TStringOrNumber;
+    placeholder?: string;
+    cols?: number;
+    rows?: number;
+    disabled?: boolean;
+    onChange?: (evt: ChangeEvent<HTMLTextAreaElement>) => void;
+    onKeyPress?: (evt: KeyboardEvent_2<HTMLTextAreaElement>) => void;
+    onFocus?: (evt: FocusEvent_2<HTMLTextAreaElement>) => void;
+    onBlur?: (evt: FocusEvent_2<HTMLTextAreaElement>) => void;
+    tabIndex?: number;
+    error?: TStringOrNumber | React_2.ReactNode;
+    warning?: TStringOrNumber | React_2.ReactNode;
+    tooltip?: TStringOrNumber | React_2.ReactNode;
+    maxTooltipWidth?: TStringOrNumber;
+    resize?: Property.Resize;
+    monospace?: boolean;
+    testId?: string;
+}
+
+export declare interface ITextLinkProps {
+    href?: string;
+    target?: string;
+    testId?: string;
+    onClick?: (e: React_2.MouseEvent<HTMLAnchorElement, MouseEvent>) => void;
+    children?: React_2.ReactNode;
+}
+
+export declare interface ITextProps {
+    bold?: boolean;
+    center?: boolean;
+    error?: boolean;
+    faint?: boolean;
+    link?: boolean;
+    muted?: boolean;
+    onClick?: (e: React_2.MouseEvent<HTMLSpanElement>) => void;
+    small?: boolean;
+    success?: boolean;
+    warning?: boolean;
+    children?: React_2.ReactNode;
+}
+
+export declare interface IToastProps {
+    id?: Id;
+    message: IMessageType;
+    autoClose?: number;
+    onClose?: TEmpty;
+}
+
+export declare interface IToggleProps {
+    name?: string;
+    label?: string | React_2.ReactElement | null;
+    checked?: boolean;
+    disabled?: boolean;
+    small?: boolean;
+    onChange: (evt: React_2.ChangeEvent<HTMLInputElement>) => void;
+    noMargin?: boolean;
+    testId?: string;
+    helpText?: string;
+    onClickHelp?: (evt: any) => void;
+}
+
+export declare interface ITooltipProps {
+    text?: TStringOrNumber | ReactNode;
+    error?: boolean;
+    warning?: boolean;
+    placement?: Placement;
+    possiblePlacements?: Placement[];
+    enabled?: boolean;
+    maxWidth?: TStringOrNumber;
+    triggerOffset?: number;
+    fontSize?: TStringOrNumber;
+    padding?: TStringOrNumber;
+    display?: string;
+    flex?: string;
+    forceOpen?: boolean;
+    children?: ReactNode;
+}
+
+declare interface ITopBarAppSwitcherProps {
+    icon?: React_2.ReactNode;
+    url?: string;
+    onClick?: MouseEventHandler<HTMLDivElement | HTMLAnchorElement>;
+}
+
+export declare interface ITopBarProps {
+    title?: ITopBarTitleProps;
+    appSwitcher?: ITopBarAppSwitcherProps;
+    content?: TTopBarContent[];
+    contentRight?: TTopBarContent[];
+    warning?: string;
+    height?: TStringOrNumber;
+    fixedPosition?: boolean;
+}
+
+declare interface ITopBarTitleProps {
+    label?: string | null;
+    logo?: React_2.ReactNode;
+    url?: string;
+    version?: TStringOrNumber;
+    onClick?: MouseEventHandler<HTMLDivElement | HTMLAnchorElement>;
+}
+
+declare interface ITreeListProps {
+    name?: string | React_2.ReactNode;
+    noHeader?: boolean;
+    items: {
+        id: TStringOrNumber;
+        name: string | React_2.ReactNode;
+        parent: TStringOrNumber;
+        droppable?: boolean;
+        details?: string | React_2.ReactNode;
+        active?: boolean;
+        testId?: string;
+        icon?: {
+            icon: React_2.ReactNode;
+            color: string;
+            tooltip?: {
+                text: TStringOrNumber | React_2.ReactNode;
+                error?: boolean;
+                warning?: boolean;
+                placement?: string;
+                enabled?: boolean;
+                maxWidth?: TStringOrNumber;
+                triggerOffset?: TStringOrNumber;
+                possiblePlacements?: string[];
+                fontSize?: TStringOrNumber;
+                padding?: TStringOrNumber;
+            };
+        };
+    }[];
+    onClick?: TEmpty;
+    actions?: any[];
+}
+
+export declare interface ITreeProps {
+    list: ITreeListProps;
+    draggable?: boolean;
+    onListReorder?: (newList: any[]) => void;
+    onChangeOpen?: (id: TStringOrNumber) => void;
+    testId?: string;
+    isInitialOpen?: boolean;
+    treeRef?: RefObject<any>;
+    itemHasChild?: TFunction;
+    onItemToggle?: TFunction;
+}
+
+export declare const Label: ({ label, width, helpText, helpTextMaxWidth, onClickHelp, lock, info, libraryIcon, labelLeft, }: ILabelProps) => JSX_2.Element;
+
+export declare const List: ({ list, bordered, expanding, narrow, toggleNarrow, onToggleNarrow, invokeEditOnRowClick, noHeader, stickyHeader, draggable, onListReorder, marginBottom, height, testId, scrollDetails, }: IListProps) => JSX_2.Element;
+
+export declare const ListHeading: React_2.ForwardRefExoticComponent<IListHeadingProps & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const ListSubheading: React_2.ForwardRefExoticComponent<IListSubheadingProps & React_2.RefAttributes<(HTMLDivElement | null)[]>>;
+
+export declare const Loader: ({ width, height, text, details, fullViewPortSize, cover, children, theme, testId, }: ILoaderProps) => JSX_2.Element;
+
+export declare const Menu: (props: IMenuProps) => JSX_2.Element;
+
+export declare enum MenuCarat {
+    FALSE = "false",
+    RIGHT = "right",
+    DOWN = "down"
+}
+
+export declare enum MenuType {
+    HEADING = "Heading",
+    DIVIDER = "Divider",
+    OPTION = "Option",
+    MENU = "Menu"
+}
+
+export declare const Message: ({ message }: IMessageProps) => JSX_2.Element;
+
+export declare enum MessageType {
+    INFO = "Info",
+    SUCCESS = "Success",
+    WARNING = "Warning",
+    ERROR = "Error"
+}
+
+export declare const Modal: ({ children, visible, centered, width, }: IModalProps) => JSX_2.Element;
+
+export declare const NativeSelect: ({ disabled, error, warning, tooltip, options, onChange, onFocus, onBlur, right, small, tabIndex, selectedOption, width, groupOrder, testId, isInTable, clearable, placeholder, hasNonExistentValue, maxTooltipWidth, borderRadius, }: INativeSelectProps) => JSX_2.Element;
+
+export declare const NumberInput: ({ name, placeholder, disabled, error, left, small, width, value, onChange, onFocus, tabIndex, testId, tooltip, warning, validationCallback, allowEmpty, isInTable, groupOrder, }: INumberInputProps) => JSX_2.Element;
+
+export declare const OptionDropdown: ({ name, label, options, onChange, showHeader, maxHeight, }: IOptionDropdownProps) => ReactElement;
+
+export declare const Page: ({ children, left, padding: paddingProp, scroll, top, }: ILayoutPageProps) => JSX_2.Element;
+
+export declare const Pagination: ({ pagination }: IPaginationProps) => JSX_2.Element;
+
+export declare const PopConfirm: ({ children, placement, closeOnOutsideClick, fullWidth, title, cancelText, onClickCancel, okText, onClickOk, overflowContainer, testId, }: IPopConfirmProps) => JSX_2.Element;
+
+export declare const Popover: ({ children, content, placement, closeOnOutsideClick, fullWidth, showCloseButton, testId, disabled, overflowContainer, }: IPopoverProps) => JSX_2.Element;
+
+export declare const Portal: ({ id, children }: IPortalProps) => ReactPortal | null;
+
+export declare const PrintHeader: ({ logo, alt, logoWidth, }: IPrintHeaderProps) => JSX_2.Element;
+
+export declare const ProgressBar: ({ width, inverted, colored, showProgressColors, percentage, noLabel, }: IProgressBarProps) => JSX_2.Element;
+
+export declare const RadioButton: ({ name, label: rawLabel, options: rawOptions, value: rawValue, onChange, disabled, small, noMargin, onClick, inline, mainLabel, radioButtonsData, classForContainer, }: IRadioButtonProps) => JSX_2.Element;
+
+export declare const readFile: (file?: Blob, method?: TFileReaderMethod) => Promise<string | ArrayBuffer | null>;
+
+export declare const RichTextInput: React_2.ForwardRefExoticComponent<IRichTextInputProps & React_2.RefAttributes<any>>;
+
+export declare const Row: ({ alignItems, justifyContent, children, flex, height, marginBottom, marginTop, spacing, wrap, testId, }: IRowProps) => JSX_2.Element;
+
+export declare const Select: (props: ISelectProps) => JSX_2.Element;
+
+export declare const SideBar: React_2.MemoExoticComponent<({ options, startOpen, onShiftClickToggleOpen, top, }: ISideBarProps) => JSX_2.Element>;
+
+export declare const Slider: ({ name, label, width, labelWidth, value, min, max, step, marks, showArrows, showTooltip, tooltipFormatter, disabled, range, small, vertical, onChange, }: ISliderProps) => JSX_2.Element;
+
+export declare const Spacer: ({ height, width, flex, }: ISpacerProps) => JSX_2.Element;
+
+export declare const Spinner: ({ small, colored, dark, tiny, }: ISpinnerProps) => JSX_2.Element;
+
+declare type StringNumberOrNode = TStringOrNumber | ReactNode;
+
+export declare const Table: (props: ITableProps) => JSX_2.Element;
+
+export declare const Tabs: ({ name, options: rawOptions, children, value: rawValue, onChange, padding, margin, contentPadding, onChangeTab, activeTabIndex: rawActiveTabIndex, tabs: tabsConfig, testId, }: ITabsProps) => JSX_2.Element | null;
+
+export declare type TAlign = 'left' | 'right' | 'center';
+
+declare type TBaseElementProps = {
+    label?: string | null;
+    icon?: ReactNode;
+    onClick?: TEmpty;
+    testId?: string;
+};
+
+export declare type TBreadcrumbLinkType = 'label' | 'link' | 'custom';
+
+declare type TButtonElement = TBaseElementProps & {
+    type: 'Button';
+    colored?: boolean;
+    disabled?: boolean;
+};
+
+export declare type TButtonPosition = 'top' | 'bottom';
+
+export declare type TButtonType = 'submit' | 'button' | 'reset';
+
+declare type TCellShape = IPopoverCell | IStaticCell | ISelectCell | IHelpIconCell | ILibraryIconCell | ICheckBoxCell | IIconCell | IInputCell | ILinkCell | INumberInputCell | IActionCell | ISortCell | ISliderCell | ISimpleCell;
+
+declare type TCellType = 'Static' | 'Icon' | 'Select' | 'Input' | 'NumberInput' | 'Popover' | 'CheckBox' | 'Actions' | 'Link' | 'Slider' | 'Unit' | string;
+
+export declare type TColor = 'danger' | 'red' | 'white' | 'success' | 'green' | 'muted';
+
+declare interface TCommonCell {
+    testId?: string;
+    style?: any;
+    colSpan?: number;
+    rowSpan?: number;
+    width?: number | string;
+}
+
+declare type TComponentElement = TBaseElementProps & {
+    type: 'Component';
+    component?: ReactNode;
+};
+
+declare type TEmpty = () => void;
+
+declare const Text_2: ({ children, bold, center, error, faint, link, muted, onClick, small, success, warning, }: ITextProps) => JSX_2.Element;
+export { Text_2 as Text }
+
+export declare const TextArea: ({ name, value, placeholder, cols, rows, disabled, onChange, onKeyPress, onFocus, onBlur, tabIndex, error, warning, tooltip, maxTooltipWidth, resize, monospace, testId, }: ITextAreaProps) => JSX_2.Element;
+
+export declare const TextLink: ({ children, href, target, testId, onClick, }: ITextLinkProps) => JSX_2.Element;
+
+declare type TFileReaderMethod = TInputReaderMethods | string;
+
+declare type TFunction = (...args: any[]) => any;
+
+export declare type TGroupOrder = 'first' | 'middle' | 'last';
+
+export declare enum Theme {
+    DARK = "dark",
+    WHITE = "white",
+    LIGHT = "light",
+    INHERIT = "inherit"
+}
+
+export declare type TIconType = 'library' | 'add' | 'drag' | 'drag horizontal' | 'help' | 'notification' | 'menu' | 'edit' | 'fast forward' | 'indent' | 'star' | 'list' | 'settings' | 'check' | 'lock' | 'unlock' | 'close' | 'success' | 'warning' | 'error' | 'info' | 'left' | 'collapse' | 'expand' | 'sort ascending' | 'sort descending' | 'fast backward' | 'chevron down' | 'chevron right' | 'chevron left' | 'chevron double left' | 'chevron double right';
+
+export declare type TInputReaderMethods = 'readAsText' | 'readAsArrayBuffer' | 'readAsDataURL' | 'readAsBinaryString';
+
+export declare type TInputType = 'text' | 'radio' | 'checkbox';
+
+declare type TLinkElement = TBaseElementProps & {
+    type: 'Link';
+    url?: string;
+    active?: boolean;
+    disabled?: boolean;
+};
+
+export declare type TMenuCarat = 'false' | 'right' | 'down';
+
+declare type TMenuElement = TBaseElementProps & {
+    type: 'Menu';
+    sections?: any[] | ReactNode;
+};
+
+export declare type TMenuType = 'Heading' | 'Divider' | 'Option' | 'Menu';
+
+export declare type TMessageType = 'Info' | 'Success' | 'Warning' | 'Error';
+
+export declare const toast: ({ id, message, autoClose, onClose, }: IToastProps) => void | React_2.ReactText;
+
+export { Toaster }
+
+export declare const Toggle: ({ name, label, checked, disabled, small, onChange, noMargin, testId, helpText, onClickHelp, }: IToggleProps) => JSX_2.Element;
+
+export declare const Tooltip: ({ children, text, error, placement, possiblePlacements, enabled, warning, maxWidth, triggerOffset, fontSize, padding, display, flex, forceOpen, }: ITooltipProps) => JSX_2.Element;
+
+export declare const TopBar: ({ title, appSwitcher, content, contentRight, warning, height, fixedPosition, }: ITopBarProps) => JSX_2.Element;
+
+export declare const Tree: ({ list, draggable, onListReorder, onChangeOpen, testId, isInitialOpen, treeRef, itemHasChild, onItemToggle, }: ITreeProps) => JSX_2.Element;
+
+export declare enum TriggerType {
+    TEXT = "Text",
+    BUTTON = "Button",
+    DROP_DOWN_BUTTON = "DropDownButton",
+    COMPONENT = "Component"
+}
+
+declare type TRowsType = TRowType[];
+
+declare type TRowType = {
+    cells: TCellShape[];
+    actions?: any[];
+    testId?: string;
+    noDrag?: boolean;
+    onRowMouseEnter?: TEmpty;
+    onRowMouseLeave?: TEmpty;
+};
+
+declare type TSliderMark = {
+    value: number | string;
+    label?: number | string | ReactNode;
+    tooltip?: number | string | ReactNode;
+};
+
+declare type TStringNumberNull = string | number | null;
+
+declare type TStringOrNumber = string | number;
+
+export declare type TTheme = 'dark' | 'white' | 'light' | 'inherit';
+
+declare type TTopBarContent = TLinkElement | TButtonElement | TMenuElement | TComponentElement;
+
+export declare type TTriggerType = 'Text' | 'Button' | 'DropDownButton' | 'Component';
+
+export declare const useFocus: () => UseFocusReturnType;
+
+declare type UseFocusReturnType = [MutableRefObject<HTMLInputElement | null>, TEmpty];
+
+export declare const useKeyboardEvent: (key: string, fn: TEmpty, dependencyList?: DependencyList) => void;
+
+export declare const useWindowWidth: () => number;
+
+export declare const widthOfCharacters: (characterCount: number) => string;
+
+export { }