/// <reference types="react" />
import React$1, { PropsWithChildren, ReactNode } from 'react';
import { IconProps } from '@phosphor-icons/react';
export * from '@phosphor-icons/react';
import { DropdownItemProps as DropdownItemProps$1, DropdownMenuProps as DropdownMenuProps$1, ButtonDropdownProps as ButtonDropdownProps$1, DropdownToggleProps as DropdownToggleProps$1, InputProps as InputProps$1, LabelProps as LabelProps$1 } from 'reactstrap';

interface AriaAttributeProps {
    'aria-label'?: string;
    'aria-labelledby'?: string;
}
type CoreSpacing = 0 | 1 | 2 | 3 | 4 | 5;
type Spacing = CoreSpacing | 'auto';
interface SpacingProps {
    margin?: Spacing;
    marginBottom?: Spacing;
    marginLeft?: Spacing;
    marginRight?: Spacing;
    marginTop?: Spacing;
    marginX?: Spacing;
    marginY?: Spacing;
    padding?: Spacing;
    paddingBottom?: Spacing;
    paddingLeft?: Spacing;
    paddingRight?: Spacing;
    paddingTop?: Spacing;
    paddingX?: Spacing;
    paddingY?: Spacing;
    wrap?: boolean;
}
interface FlexContainerProps {
    alignItems?: 'center' | 'start' | 'end' | 'baseline';
    direction?: 'row' | 'column';
    flex?: boolean | number;
    justifyContent?: 'center' | 'start' | 'end' | 'flex-start' | 'flex-end' | 'left' | 'right' | 'normal' | 'between' | 'space-around' | 'space-evenly';
    wrap?: boolean;
}
interface FlexItemProps {
    alignSelf?: 'auto' | 'flex-start' | 'flex-end' | 'center' | 'baseline' | 'stretch';
    flexGrow?: 0 | 1;
    flexShrink?: 0 | 1;
}
interface OverflowProps {
    overflow?: 'auto' | 'hidden' | 'scroll';
    overflowX?: 'auto' | 'hidden';
    overflowY?: 'auto' | 'hidden';
}
type DesignSystemColor = 'blue' | 'blue-dark' | 'blue-light' | 'blue-lightest' | 'green' | 'green-dark' | 'green-light' | 'green-lightest' | 'orange' | 'orange-dark' | 'orange-light' | 'orange-lightest' | 'pink' | 'pink-dark' | 'pink-light' | 'pink-lightest' | 'purple' | 'purple-dark' | 'purple-light' | 'purple-lightest' | 'red' | 'red-dark' | 'red-light' | 'red-lightest' | 'yellow' | 'yellow-dark' | 'yellow-light' | 'yellow-lightest' | 'black' | 'gray-darker' | 'gray-dark' | 'gray' | 'gray-light' | 'gray-lighter' | 'white';
type SystemBackgroundColor = DesignSystemColor;
type BootstrapColor = 'primary' | 'white' | 'light' | 'gray-light' | 'secondary' | 'success' | 'warning' | 'info' | 'dark' | 'danger';
type BorderWidth = 0 | 1;
type BorderRadius = 0 | 1 | 2;
interface BorderProps {
    border?: BorderWidth;
    borderBottom?: BorderWidth;
    borderColor?: BootstrapColor;
    borderLeft?: BorderWidth;
    borderRadius?: BorderRadius;
    borderRight?: BorderWidth;
    borderTop?: BorderWidth;
    borderX?: BorderWidth;
    borderY?: BorderWidth;
}
type TextSize = 1 | 2 | 3;
type TextColor = 'danger' | 'warning' | 'success' | 'primary' | DesignSystemColor;
interface TextStyleProps {
    align?: 'left' | 'center' | 'right';
    legacyColor?: TextColor;
    light?: boolean;
    lineClamp?: 1 | 2 | 3;
    size?: TextSize;
}
type BootstrapSize = 'sm' | 'md' | 'lg';
interface ClickableProps$1 {
    disabled?: boolean;
    external?: boolean;
    href?: string;
    onClick?: React$1.MouseEventHandler;
}
declare enum LabelPlacement {
    Left = "Left",
    Right = "Right"
}

interface AnchorProps extends ClickableProps$1, Omit<React$1.HTMLAttributes<HTMLElement>, 'onClick' | 'className'> {
    children: React$1.ReactNode;
    dark?: boolean;
    disabled?: boolean;
    noDecoration?: boolean;
}
declare const Anchor: React$1.FC<AnchorProps>;

type BadgeColor = 'blue' | 'danger' | 'gray-light' | 'orange-lightest' | 'primary' | 'success' | 'warning' | 'white';
interface BadgeProps extends AriaAttributeProps {
    children: React$1.ReactNode;
    color?: BadgeColor;
}
declare const Badge: React$1.FC<BadgeProps>;

interface BoxProps extends FlexContainerProps, FlexItemProps, OverflowProps, SpacingProps, BorderProps {
    backgroundColor?: BootstrapColor | SystemBackgroundColor;
    children: React$1.ReactNode;
    component?: keyof React$1.ReactHTML;
    fullHeight?: boolean;
    fullWidth?: boolean;
    id?: string;
}
declare const Box: React$1.ForwardRefExoticComponent<BoxProps & React$1.RefAttributes<HTMLElement>>;

interface BreadcrumbItem extends Pick<AnchorProps, 'external' | 'href' | 'onClick'> {
    name?: string;
    names?: string[];
}
interface BreadcrumbProps {
    items: BreadcrumbItem[];
    showIcon?: boolean;
}
declare const Breadcrumb: React$1.FC<BreadcrumbProps>;

type IconComponentType = React.ElementType<IconProps>;

type Color = 'primary' | 'secondary' | 'danger' | 'success' | 'warning' | 'white' | 'gray' | 'link' | 'purple' | 'blue' | 'green' | 'red' | 'orange';
type LegacyColor = 'gray-dark' | 'purple' | 'red';
interface ButtonProps extends AriaAttributeProps, Pick<AnchorProps, 'external' | 'href' | 'title'>, Pick<TextStyleProps, 'align'> {
    block?: boolean;
    children?: React$1.ReactNode;
    color?: Color;
    disabled?: boolean;
    icon?: IconComponentType;
    id?: string;
    legacyColor?: LegacyColor;
    loading?: boolean;
    nowrap?: boolean;
    onClick?: React$1.MouseEventHandler<HTMLButtonElement>;
    outline?: boolean;
    size?: BootstrapSize;
    tight?: boolean;
    type?: 'submit' | 'reset' | 'button' | undefined;
}
declare const Button: React$1.ForwardRefExoticComponent<ButtonProps & React$1.RefAttributes<HTMLButtonElement>>;

interface CardProps extends AriaAttributeProps, ClickableProps$1, FlexContainerProps {
    border?: boolean;
    children: React$1.ReactNode;
    'data-testid'?: string;
    disabled?: boolean;
    fill?: boolean;
    fullHeight?: boolean;
    fullWidth?: boolean;
    selected?: boolean;
    tight?: boolean;
}
declare const Card: React$1.ForwardRefExoticComponent<CardProps & React$1.RefAttributes<HTMLElement>>;

interface CheckboxProps extends AriaAttributeProps {
    checked: boolean;
    disabled?: boolean;
    id?: React$1.HTMLAttributes<any>['id'];
    label: string;
    labelPlacement?: LabelPlacement;
    lightLabel?: boolean;
    onChange: (event: React$1.ChangeEvent<HTMLButtonElement>) => void;
    value?: string;
}
declare const Checkbox: React$1.FC<CheckboxProps>;

interface ClickableProps extends AriaAttributeProps, SpacingProps, BorderProps, FlexContainerProps, ClickableProps$1, Omit<React$1.HTMLAttributes<HTMLElement>, 'onClick' | 'className'> {
    children: React$1.ReactNode;
    fullHeight?: boolean;
    fullWidth?: boolean;
    hoverColor?: boolean;
}
declare const Clickable: React$1.ForwardRefExoticComponent<ClickableProps & React$1.RefAttributes<HTMLElement>>;

interface DropdownOption extends AriaAttributeProps {
    icon?: IconComponentType;
    key: string;
    label: React$1.ReactNode;
}
interface DropdownProps {
    defaultSelected?: string;
    defaultText?: string;
    disabled?: boolean;
    label?: string;
    light?: boolean;
    onReset?: () => void;
    onSelect: (optionKey: string) => void;
    options: DropdownOption[];
    selected?: string;
    showReset?: boolean;
    size?: BootstrapSize;
    tight?: boolean;
    truncateText?: boolean;
}
declare const Dropdown: React$1.FC<DropdownProps>;

type DropdownItemProps = Omit<DropdownItemProps$1, 'className'>;
declare const DropdownItem: React$1.FC<DropdownItemProps>;

type DropdownMenuProps = Omit<DropdownMenuProps$1, 'className'>;
declare const DropdownMenu: React$1.FC<DropdownMenuProps>;

type ButtonDropdownProps = ButtonDropdownProps$1;
declare const ButtonDropdown: React$1.FC<ButtonDropdownProps>;

type DropdownToggleProps = Omit<DropdownToggleProps$1, 'className'>;
declare const DropdownToggle: React$1.FC<DropdownToggleProps>;

interface FancyToggleOption {
    'aria-label'?: string;
    description?: string;
    disabled?: boolean;
    key: string;
    label: React$1.ReactNode;
    tooltip?: string;
}
interface FancyToggleProps {
    defaultSelected?: string;
    nowrap?: boolean;
    onChange: (key: string) => void;
    options: FancyToggleOption[];
    textCentered?: boolean;
    textSize?: TextSize;
    tight?: boolean;
    value?: string;
    vertical?: boolean;
}
declare const FancyToggle: React$1.FC<FancyToggleProps>;

interface FormLabelProps {
    htmlFor?: string;
    label: string;
    light?: boolean;
}
declare const FormLabel: React$1.FC<FormLabelProps>;

interface IconAnimationProps extends IconProps {
    duration?: number;
    icon: IconComponentType;
    type: 'spin' | 'scale-in' | 'fade-in' | 'spin-tick';
}
declare const IconAnimation: React$1.FC<IconAnimationProps>;

interface IconBadgeProps extends IconProps {
    border?: 0 | 1;
    borderColor?: IconProps['color'];
    color?: IconProps['color'];
    colorForeground?: IconProps['color'];
    icon: IconComponentType;
    iconBackground?: IconComponentType;
    sizeForeground?: IconProps['size'];
}
declare const IconBadge: React$1.FC<IconBadgeProps>;

type InputProps = InputProps$1;
declare const Input: React$1.FC<InputProps>;

type LabelProps = LabelProps$1;
declare const Label: React$1.FC<LabelProps>;

type BootstrapNumberColor = 'success' | 'warning' | 'danger' | 'none';
interface LinearPercentageProps extends AriaAttributeProps {
    boldLabel?: boolean;
    color?: BootstrapNumberColor;
    label: React$1.ReactNode;
    labelPlacement?: LabelPlacement;
    percent: number;
    size?: BootstrapSize;
}
declare const LinearPercentage: React$1.FC<LinearPercentageProps>;

interface StackProps extends Omit<FlexContainerProps, 'direction'>, FlexItemProps, OverflowProps, SpacingProps {
    children: React$1.ReactNode;
    component?: React$1.ElementType;
    customDivider?: React$1.ReactNode;
    divider?: boolean;
    fullHeight?: boolean;
    fullWidth?: boolean;
    id?: string;
    row?: boolean;
    spacing?: CoreSpacing;
}
declare const Stack: React$1.FC<StackProps>;

interface ListProps extends Pick<StackProps, 'children' | 'divider' | 'spacing' | 'component' | 'flex'> {
    children: React$1.ReactNode;
}
declare const List: React$1.FC<ListProps>;

interface ListItemProps extends AriaAttributeProps, ClickableProps$1, Pick<BoxProps, 'component'>, FlexContainerProps {
    border?: BorderWidth;
    children: React$1.ReactNode;
    fullHeight?: boolean;
    fullWidth?: boolean;
    id?: string;
    tight?: boolean;
}
declare const ListItem: React$1.ForwardRefExoticComponent<ListItemProps & React$1.RefAttributes<HTMLElement>>;

interface LoaderProps {
    centered?: boolean;
    disableText?: boolean;
    size?: IconProps['size'];
    small?: boolean;
    text?: string;
    top?: boolean;
}
declare const Loader: React$1.FC<LoaderProps>;

interface LogoProps {
    icon?: 'primary' | 'color' | 'dark' | 'reverse' | 'hide';
    mark?: 'primary' | 'dark' | 'reverse' | 'hide';
}
declare const Logo: React$1.FC<LogoProps>;

interface ModalProps {
    children: React$1.ReactNode;
    disablePadding?: boolean;
    disableScrolling?: boolean;
    error?: string;
    footer?: React$1.ReactNode;
    height?: '60' | '80';
    isOpen: boolean;
    maxWidth?: boolean;
    size?: 'sm' | 'md' | 'lg' | 'xl';
    title?: string;
    toggleModal: () => void;
}
declare const Modal: React$1.FC<ModalProps>;

type Colors = 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'blue';
interface PillProps extends AriaAttributeProps, ClickableProps$1 {
    children: React$1.ReactNode;
    color?: Colors;
    small?: boolean;
    title?: string;
}
declare const Pill: React$1.FC<PillProps>;

declare const CortexPortal: React$1.FC<PropsWithChildren>;

declare const CortexPortalRoot: React$1.FC;

interface ProgressBarProps extends AriaAttributeProps {
    max?: number;
    value: number;
}
declare const ProgressBar: React$1.FC<ProgressBarProps>;

interface TableColumn {
    Cell?: React$1.FC<any>;
    accessor?: string;
    id: string;
    title: string;
    width?: string;
}
interface TableConfig {
    columns: TableColumn[];
    showHeader?: boolean;
}
interface SimpleTableProps<T> {
    config: TableConfig;
    items: T[];
}
declare function SimpleTable<T>({ config, items }: SimpleTableProps<T>): React$1.JSX.Element;

declare const Table: React$1.FC<PropsWithChildren>;

declare enum TabPlacement {
    Bottom = "Bottom",
    Left = "Left",
    Right = "Right"
}
interface BaseTabItem {
    name: string;
}
interface TabItem extends BaseTabItem {
    badge?: string;
    count?: number;
    disabled?: boolean;
    icon?: IconComponentType;
}
interface TabsProps {
    initialTab?: string;
    onClickCallback?: (tabName: string) => void;
    placement?: TabPlacement;
    renderTab: (tabName: string) => React$1.ReactElement;
    rightComponent?: React$1.ReactNode;
    tabs: TabItem[];
    tabsAnalyticsName?: string;
    tall?: boolean;
}
declare const Tabs: React$1.FC<TabsProps>;

interface TagProps extends Pick<TextStyleProps, 'lineClamp'>, Omit<React$1.HTMLAttributes<HTMLDivElement>, 'className'> {
    children: React$1.ReactNode;
    dark?: boolean;
    small?: boolean;
    solid?: boolean;
}
declare const Tag: React$1.FC<TagProps>;

interface BaseTextProps extends Omit<React$1.HtmlHTMLAttributes<any>, 'className'>, TextStyleProps {
    bold?: boolean;
    children: React$1.ReactNode;
    component?: keyof React$1.ReactHTML;
    id?: string;
    italic?: boolean;
    monospace?: boolean;
    nowrap?: boolean;
    underline?: boolean;
    uppercase?: boolean;
}
interface LabelTextProps extends BaseTextProps, Omit<React$1.LabelHTMLAttributes<any>, 'className'> {
    children: React$1.ReactNode;
    component: 'label';
}
type TextProps = BaseTextProps | LabelTextProps;
declare const Text: React$1.FC<TextProps>;

interface TitleProps extends Omit<React$1.HTMLAttributes<HTMLHeadingElement>, 'className'> {
    children: React$1.ReactNode;
    legacyColor?: 'primary';
    level: 1 | 2;
    noMarginBottom?: boolean;
    tight?: boolean;
}
declare const Title: React$1.FC<TitleProps>;

interface ToggleProps extends AriaAttributeProps {
    checked?: boolean;
    defaultChecked?: boolean;
    disabled?: boolean;
    id?: string;
    onChange?: (event: React$1.ChangeEvent<HTMLInputElement>) => void;
}
declare const Toggle: React$1.FC<ToggleProps>;

type TypeaheadModel = string | object;
type TypeaheadLabelKey<T> = (option: T) => React$1.ReactChild | React$1.ReactFragment;
type TypeaheadProps<T extends TypeaheadModel> = {
    allowNew?: T extends object ? never : boolean;
    clearable?: boolean;
    disableSorting?: boolean;
    disabled?: boolean;
    id?: string;
    isLoading?: boolean;
    labelKey?: TypeaheadLabelKey<T>;
    multiple?: boolean;
    onBlur?: () => void;
    onChange?: (selected: T[]) => void;
    options: T[];
    placeholder?: string;
    selected?: T[];
    sortBy?: (left: T, right: T) => number;
} & AriaAttributeProps;
declare function Typeahead<T extends TypeaheadModel>({ allowNew, disableSorting, labelKey, options, sortBy, clearable, ...otherProps }: TypeaheadProps<T>): React$1.JSX.Element;

declare enum PluginContextLocation {
    Entity = "ENTITY",
    Global = "GLOBAL"
}

declare enum CortexUserRoleType {
    BASIC = "BASIC",
    CUSTOM = "CUSTOM"
}
declare enum CortexBasicUserRole {
    MANAGER = "MANAGER",
    OWNER = "OWNER",
    USER = "USER",
    VIEWER = "VIEWER"
}
interface CortexUserBasicRole {
    role: CortexBasicUserRole;
    type: CortexUserRoleType.BASIC;
}
interface CortexUserCustomRole {
    name: string;
    tag: string;
    type: CortexUserRoleType.CUSTOM;
}
type CortexUserRole = CortexUserBasicRole | CortexUserCustomRole;
interface CortexUser {
    email: string;
    name: string;
    roles?: CortexUserRole[];
}
interface CortexEmailOwner {
    description: string | null;
    email: string;
}
interface PluginEntityOwnership {
    emails: CortexEmailOwner[];
}
interface CortexCatalogEntity {
    definition: any | null;
    description: string | null;
    groups: string[] | null;
    name: string | null;
    ownership: PluginEntityOwnership;
    tag: string;
    type: string;
}
interface CortexService extends CortexCatalogEntity {
    type: 'service';
}
interface CortexResource extends CortexCatalogEntity {
    type: string;
}
interface CortexDomain extends CortexCatalogEntity {
    type: 'domain';
}
interface CortexContextResponse {
    apiBaseUrl: string;
    entity: CortexDomain | CortexResource | CortexService | null;
    location: PluginContextLocation;
    style: Record<string, string>;
    tag: string;
    theme: string;
    user: CortexUser;
}

interface PluginContextProviderProps extends React$1.PropsWithChildren {
    monkeyPatchFetch?: boolean;
}
interface IPluginContext {
    context: CortexContextResponse;
    setContext: (context: CortexContextResponse) => void;
}
declare const PluginContext: React$1.Context<IPluginContext>;
declare const PluginContextProvider: React$1.FC<PluginContextProviderProps>;

interface PluginProviderProps extends React$1.PropsWithChildren {
    monkeyPatchFetch?: boolean;
}
declare const PluginProvider: React$1.FC<PluginProviderProps>;

declare const ThemeProvider: ({ children }: {
    children: ReactNode;
}) => React$1.JSX.Element;

declare const usePluginContext: () => CortexContextResponse;

export { Anchor, AnchorProps, Badge, BadgeColor, BaseTabItem, BaseTextProps, BootstrapNumberColor, Box, BoxProps, Breadcrumb, BreadcrumbItem, Button, ButtonDropdown, ButtonProps, Card, Checkbox, Clickable, ClickableProps, CortexPortal, CortexPortalRoot, Dropdown, DropdownItem, DropdownMenu, DropdownOption, DropdownProps, DropdownToggle, FancyToggle, FancyToggleOption, FancyToggleProps, FormLabel, IPluginContext, IconAnimation, IconBadge, Input, InputProps, Label, LabelProps, LabelTextProps, LinearPercentage, List, ListItem, ListItemProps, Loader, LoaderProps, Logo, Modal, ModalProps, Pill, PillProps, PluginContext, PluginContextProvider, PluginProvider, ProgressBar, ProgressBarProps, SimpleTable, Stack, StackProps, TabItem, TabPlacement, Table, Tabs, TabsProps, Tag, TagProps, Text, TextProps, ThemeProvider, Title, TitleProps, Toggle, ToggleProps, Typeahead, TypeaheadLabelKey, TypeaheadModel, TypeaheadProps, usePluginContext };