import { ColorHues, ComponentStyleConfig, ToastProviderProps, StackDirection, IconButtonProps, LinkProps, ChakraProps, HeadingProps as HeadingProps$1, TabsProps as TabsProps$1, ModalProps, ButtonProps as ButtonProps$1, TooltipProps as TooltipProps$2, ThemeTypings, FormControlProps, FormLabelProps, FormHelperTextProps, FormErrorMessageProps, GridProps, NumberInputProps as NumberInputProps$1, InputProps, StackProps, RadioProps, RadioGroupProps as RadioGroupProps$1, UseRadioGroupProps, SelectFieldProps, UseTooltipProps, SliderProps, SliderMarkProps, BadgeProps as BadgeProps$1, AccordionProps as AccordionProps$1, AccordionItemProps as AccordionItemProps$1, PopoverProps as PopoverProps$1, PopoverContentProps as PopoverContentProps$1, TextProps, BoxProps, SpinnerProps, ModalHeaderProps, ModalBodyProps, ImageProps } from '@chakra-ui/react';
export * from '@chakra-ui/react';
export { RadioGroup as ChakraRadioGroup } from '@chakra-ui/react';
import { GlobalStyleProps } from '@chakra-ui/theme-tools';
import { Dict } from '@chakra-ui/utils';
import { UseFormReturn, SubmitHandler, FieldValues, SubmitErrorHandler, ValidationMode, ControllerRenderProps } from 'react-hook-form';
import * as Yup from 'yup';
import { FormFieldProps as FormFieldProps$1 } from 'components/FormField/FormField';
import { RadioGroupOption as RadioGroupOption$1 } from 'components/Inputs/RadioGroup/RadioGroup';
import { RPSliderMarkProps as RPSliderMarkProps$1 } from 'components/Inputs/Slider/RPSlider';
import * as React$1 from 'react';
import React__default, { Ref, ReactNode, FC, PropsWithChildren, ReactElement, MouseEventHandler, FocusEventHandler } from 'react';
import { SelectOption as SelectOption$1, SelectOptionGroup as SelectOptionGroup$1 } from 'components/Inputs/Select/Select';
import { SelectInstance, GroupBase, MultiValue, SingleValue, Props, PropsValue } from 'chakra-react-select';
export { AsyncSelect, CreatableSelect } from 'chakra-react-select';
import { TooltipProps as TooltipProps$1 } from 'components/Inputs/Slider/chakra/ChakraTooltip';
import { ColumnSelectOption as ColumnSelectOption$1, ColumnSelectProps as ColumnSelectProps$1 } from 'components/Inputs/ColumnSelect/ColumnSelect';
import * as react_jsx_runtime from 'react/jsx-runtime';
import * as _chakra_ui_system_dist_system_types from '@chakra-ui/system/dist/system.types';
import { IconBaseProps } from 'react-icons';
import { SyntaxHighlighterProps } from 'react-syntax-highlighter';
import { ColumnDef, RowSelectionState, OnChangeFn, Row, PaginationState, SortingState } from '@tanstack/react-table';
export { PaginationState, SortingState, Updater } from '@tanstack/react-table';
import { ReactDatePickerProps } from 'react-datepicker';
import { PortalProps } from '@chakra-ui/portal';
import { HTMLChakraProps, ThemingProps } from '@chakra-ui/system';
import { HTMLMotionProps } from 'framer-motion';
import { JsonViewerProps } from '@textea/json-viewer';
import { Options } from 'react-markdown';
import { IconProps } from '@chakra-ui/icons';

declare const colors: Record<string, Partial<ColorHues>>;

declare const components: Record<string, ComponentStyleConfig>;

declare const styles: {
    global: (props: GlobalStyleProps) => {
        html: {
            textUnderlineOffset: string;
            fontSize: string;
        };
        body: {
            background: string;
            fontFamily: string;
        };
        'b, strong': {
            fontWeight: string;
        };
    };
};

declare const theme: Dict;
/**
 * This object defines default toastOptions that should be consistent across all RedPanda UIs.
 */
declare const toastOptions: ToastProviderProps;

/** React hook for localStorage
 * From https://usehooks.com/useLocalStorage/
 */
declare function useLocalStorage<T>(key: string, initialValue: T): [T, (x: T) => void];

declare function useKey(key: string, callback: () => void, propsThatChange?: unknown[]): boolean;

type FormMethods = UseFormReturn<{
    [k: string]: string | number | boolean | string[] | undefined;
}, any>;
type FieldInputMode = 'none' | 'text' | 'tel' | 'url' | 'email' | 'numeric' | 'decimal' | 'search' | 'password';
interface GenericField extends Omit<FormFieldProps$1, 'inputMode'> {
    name: string;
    value?: any;
    label: string;
    description?: string | ReactNode;
    footerDescription?: string | ReactNode;
    tooltip?: string | ReactNode;
    defaultValue?: any;
    placeholder?: string;
    help?: string;
    fieldType?: 'text' | 'password' | 'textarea' | 'number' | 'select' | 'radio' | 'hidden' | 'toggle' | 'slider' | 'displaySection' | 'columnSelect' | 'checkbox' | 'custom' | 'repeater';
    isRequired?: boolean;
    isDisabled?: boolean;
    hide?: boolean;
    schema: Yup.Schema;
    columns?: 1 | 2 | 3 | 4 | 5 | 6;
    heading?: string | ReactNode;
    inputMode?: FieldInputMode;
}
interface TextField extends GenericField {
    schema: Yup.StringSchema<string | undefined, Yup.AnyObject, undefined, ''>;
    pattern?: string;
}
interface PasswordField extends TextField {
    defaultShowPassword?: boolean;
    showEyeIndicator?: boolean;
}
interface TextAreaField extends GenericField {
    schema: Yup.StringSchema<string | undefined, Yup.AnyObject, undefined, ''>;
}
interface NumberField extends GenericField {
    schema: Yup.NumberSchema<number, Yup.AnyObject, undefined, ''>;
    min?: number;
    max?: number;
    step?: number;
}
interface ColumnSelectField extends GenericField {
    options: ColumnSelectOption$1[];
    innerRef?: Ref<SelectInstance<SelectOption$1, boolean, GroupBase<SelectOption$1>>>;
    isLoading?: boolean;
    headerColumns: ColumnSelectProps$1['headerColumns'];
    singleValueText?: ColumnSelectProps$1['singleValueText'];
    firstTextPosition?: ColumnSelectProps$1['firstTextPosition'];
    footer?: ColumnSelectProps$1['footer'];
}
interface SelectField extends GenericField {
    options: SelectOption$1[] | SelectOptionGroup$1[];
    isMulti?: boolean;
    innerRef?: Ref<SelectInstance<SelectOption$1, boolean, GroupBase<SelectOption$1>>>;
    max?: number;
    isLoading?: boolean;
}
interface HiddenField extends GenericField {
    schema: Yup.StringSchema<string | undefined, Yup.AnyObject, undefined, ''>;
}
interface RadioField extends GenericField {
    options: RadioGroupOption$1[];
    isAttached?: boolean;
    radioVariant?: 'circle' | 'card';
    radioStackDirection?: StackDirection;
}
interface ToggleField extends GenericField {
    schema: Yup.StringSchema<string, Yup.AnyObject, undefined, ''>;
}
type SliderFieldInputMode = 'none' | 'text' | 'tel' | 'url' | 'email' | 'numeric' | 'decimal' | 'search';
interface SliderField extends Omit<GenericField, 'inputMode'> {
    schema: Yup.NumberSchema<number, Yup.AnyObject, undefined, ''>;
    min?: number;
    max?: number;
    step?: number;
    marks?: RPSliderMarkProps$1[];
    sliderTooltip?: Omit<TooltipProps$1, 'children'>;
    inputMode?: SliderFieldInputMode;
}
interface DisplaySection extends GenericField {
    schema: Yup.StringSchema<string | undefined, Yup.AnyObject, undefined, ''>;
    fieldType: 'displaySection';
}
interface CheckboxField extends GenericField {
    schema: Yup.StringSchema<string, Yup.AnyObject, undefined, ''>;
    text: string | ReactNode;
}
interface RepeaterField extends Omit<GenericField, 'schema'> {
    fieldType: 'repeater';
    schema: Yup.ArraySchema<{
        [key: string]: string;
    }[] | undefined, Yup.AnyObject, '', ''>;
}
interface CustomFormSection extends Omit<GenericField, 'schema'> {
    fieldType: 'custom';
    fields: CustomField[];
    component: React.ComponentType<CustomFormSectionProps>;
}
type CustomFormSectionProps = {
    form: UseFormReturn<{
        [x: string]: any;
        [x: number]: any;
    }, any, undefined>;
    setValidationContext?: React.Dispatch<React.SetStateAction<{}>>;
};
type CustomField = TextField | PasswordField | TextAreaField | NumberField | SelectField | HiddenField | RadioField | ToggleField | SliderField | DisplaySection | ColumnSelectField | CheckboxField | CustomFormSection | RepeaterField;

declare const useReactHookForm: () => {
    formValues: Record<string, any> | undefined;
    setFormValues: (_values: Record<string, unknown>) => void;
    formMethods: FormMethods | undefined;
    setFormMethods: (_values: FormMethods) => void;
};

/**
 *
 * @param animationName The unique name of the animation to be synchronized
 * @returns a reference to the object with the synchronized animation time
 */
declare function useSynchronizedAnimation<T>(animationName: string): React$1.MutableRefObject<T | undefined>;

type ColorModeSwitcherProps = Omit<IconButtonProps, 'aria-label'>;
declare const ColorModeSwitch: React__default.FC<ColorModeSwitcherProps>;

type LogoProps = {
    alt: string;
    height?: number;
    isCollapsed?: boolean;
    overrides?: {
        lightModeTextSvg: string;
        lightModeIconSvg: string;
        darkModeTextSvg: string;
        darkModeIconSvg: string;
    };
};
declare function Logo(props: LogoProps): react_jsx_runtime.JSX.Element;

declare const status: readonly ["success", "error", "loading"];
type StatusEnum = typeof status[number];

type NavLinkProps = {
    title: string;
    to: string;
    icon: any;
    onClick?: LinkProps['onClick'];
    isPrevious?: boolean;
    isIconOnly?: boolean;
    isExternal?: boolean;
    isCollapsed?: boolean;
    isDisabled?: boolean;
    disabledText?: string;
    status?: StatusEnum;
};
declare function NavLink(props: NavLinkProps): react_jsx_runtime.JSX.Element;

type SidebarItemProps = NavLinkProps;
type SidebarGroup = {
    heading: string;
    items: SidebarItemProps[];
};
type SidebarProps = {
    previousItem?: SidebarItemProps;
    items?: SidebarItemProps[];
    groups?: SidebarGroup[];
    footerItems?: SidebarItemProps[];
    children?: ReactNode;
    footerChildren?: ReactNode;
    isCollapsible?: boolean;
    isCollapsed?: boolean;
    logoOverrides?: LogoProps['overrides'];
    status?: StatusEnum;
};
declare function Sidebar({ previousItem, items, groups, footerItems, isCollapsible, isCollapsed: initialIsCollapsed, logoOverrides, status, children, footerChildren, }: SidebarProps): react_jsx_runtime.JSX.Element;

type BaseLayoutProps = {
    children: React__default.ReactNode;
    sidebar: SidebarProps | false;
};
declare function BaseLayout(props: BaseLayoutProps): react_jsx_runtime.JSX.Element;

type SectionProps = {
    children: ReactNode;
    variant?: 'primary' | 'secondary';
    autoHeight?: boolean;
    testId?: string;
} & ChakraProps;
declare function Section({ variant, testId, ...props }: SectionProps): react_jsx_runtime.JSX.Element;

type KeysOfValue<T, TCondition> = {
    [K in keyof T]: T[K] extends TCondition ? K : never;
}[keyof T];
declare const sizeToVariant: {
    readonly xl: "xl";
    readonly lg: "xl";
    readonly md: "lg";
    readonly sm: "md";
    readonly xs: "sm";
};
type As = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
type Variants = (typeof sizeToVariant)[keyof typeof sizeToVariant];
type Sizes$1 = KeysOfValue<typeof sizeToVariant, string>;
type BaseHeadingProps = Omit<HeadingProps$1, 'as' | 'variant' | 'size'> & {
    as?: As;
};
type HeadingWithVariant = BaseHeadingProps & {
    variant: Variants;
    size?: never;
};
type HeadingWithSize = BaseHeadingProps & {
    /** @deprecated use 'variant' instead */
    size?: Sizes$1;
    variant?: never;
};
type HeadingProps = HeadingWithVariant | HeadingWithSize;
declare const Heading: ({ variant, size, as, ...rest }: HeadingProps) => react_jsx_runtime.JSX.Element;

declare function SectionHeading({ variant, size, ...rest }: HeadingProps): react_jsx_runtime.JSX.Element;

declare function SectionSubheading({ variant, size, ...rest }: HeadingProps): react_jsx_runtime.JSX.Element;

declare function SectionDivider(): react_jsx_runtime.JSX.Element;

type BreadcrumbItemProps = {
    name: string;
    to: string;
    heading?: string;
    options?: {
        canBeTruncated?: boolean;
        canBeCopied?: boolean;
    };
};
type BreadcrumbsProps = {
    items?: BreadcrumbItemProps[];
    showHomeIcon?: boolean;
};
declare function Breadcrumbs(props: BreadcrumbsProps): react_jsx_runtime.JSX.Element;

type NavProps = {
    heading?: string;
    items?: NavLinkProps[];
    isCollapsed?: boolean;
    status?: StatusEnum;
};
declare function Nav(props: NavProps): react_jsx_runtime.JSX.Element | null;

type StepsItemProps = {
    index: number;
    name: string | ReactNode;
    description?: string | ReactNode;
    status: 'incomplete' | 'complete' | 'current';
    onClick?: (index: number) => void;
    isTextVisible?: boolean;
    showTrack: boolean;
    direction?: 'vertical' | 'horizontal';
    gap: string;
};

type StepsProps = {
    currentIndex: number;
    items?: Omit<StepsItemProps, 'index' | 'status' | 'gap' | 'showTrack'>[];
    onClick?: (index: number) => void;
    gap?: string;
    isTextVisible?: boolean;
    direction?: 'horizontal' | 'vertical';
};
declare function Steps(props: StepsProps): react_jsx_runtime.JSX.Element;

type TabsItemProps = {
    key: string;
    name: ReactNode;
    component: ReactNode;
    isDisabled?: boolean | string;
};
type TabsProps = {
    items: TabsItemProps[];
    onChange?: (index: number | string, key: TabsItemProps['key']) => void;
} & Omit<TabsProps$1, 'children' | 'isLazy' | 'onChange'>;
declare const Tabs: FC<TabsProps>;

interface BaseModalProps {
    heading: ReactNode;
    children: PropsWithChildren<ReactNode>;
    isOpen: boolean;
    isClosable?: boolean;
    onClose: () => void;
    size?: ModalProps['size'];
    initialFocusRef?: ModalProps['initialFocusRef'];
}
declare const BaseModal: ({ isClosable, isOpen, heading, onClose, children, size, initialFocusRef, }: BaseModalProps) => react_jsx_runtime.JSX.Element;

type RenderProps = {
    confirm: (value?: unknown) => void;
    cancel: () => void;
    params?: any;
    isOpen: boolean;
};
type useConfirmModalProps = Pick<BaseModalProps, 'initialFocusRef' | 'heading' | 'size'> & {
    render: (props: RenderProps) => ReactNode;
};
declare const useConfirmModal: ({ heading, size, render, initialFocusRef, }: useConfirmModalProps) => {
    renderModal: () => react_jsx_runtime.JSX.Element;
    showModal: (params?: any) => Promise<any>;
};

declare const noop: () => void;

type ConfirmModalProps = Omit<BaseModalProps, 'isOpen' | 'isClosable' | 'size' | 'onClose'> & PropsWithChildren<{
    trigger: string | ReactElement;
    onConfirm: (dismiss: (value?: unknown) => void) => void;
    onClose?: typeof noop;
    primaryActionLabel?: string;
    secondaryActionLabel?: string;
    variant?: 'default' | 'delete' | 'success' | 'error';
    autoCloseOnConfirm?: boolean;
}>;
declare const ConfirmModal: (props: ConfirmModalProps) => react_jsx_runtime.JSX.Element;

type ConfirmItemDeleteModalProps = Omit<ConfirmModalProps, 'onConfirm' | 'variant' | 'heading' | 'autoCloseOnConfirm' | 'children'> & {
    itemType: string;
    onConfirm: (dismiss: (value?: unknown) => void, onError: (msg: string) => void) => void;
    heading?: ConfirmModalProps['heading'];
    children?: ConfirmModalProps['children'];
    requireValidation?: boolean;
    isDisabled?: boolean;
    inputMatchText?: string;
};
declare const ConfirmItemDeleteModal: (props: ConfirmItemDeleteModalProps) => react_jsx_runtime.JSX.Element;

interface FormProviderProps {
    children: ReactNode;
}
/**
 * @see https://react-hook-form.com/advanced-usage/#WizardFormFunnel
 */
declare const FormProvider: ({ children }: FormProviderProps) => react_jsx_runtime.JSX.Element;

declare const BUTTON_VARIANTS: readonly ["solid", "solid-brand", "brand", "outline", "outline-delete", "delete", "link", "icon", "ghost", "ghost-white", "subtle", "unstyled", "inputOutline", "nav"];
type AnyStringValue = string & NonNullable<unknown>;
type ButtonVariants = (typeof BUTTON_VARIANTS)[number];
type ButtonProps = Omit<ButtonProps$1, 'variant'> & {
    variant?: ButtonVariants | AnyStringValue;
    tooltip?: TooltipProps$2['label'];
};
declare const Button: _chakra_ui_system_dist_system_types.ComponentWithAs<"button", ButtonProps>;

interface FormButtonProps {
    text: string | ReactNode;
    label: string;
    colorScheme?: ThemeTypings['colorSchemes'];
    variant?: ButtonProps['variant'];
    spanFullWidth?: boolean;
}
interface FormProps {
    onValid: SubmitHandler<FieldValues>;
    onInvalid?: SubmitErrorHandler<FieldValues>;
    fields: CustomField[];
    button: FormButtonProps;
    autofocus?: boolean;
    mode?: keyof ValidationMode;
    developerView?: boolean;
    isDisabled?: boolean;
    isFetching?: boolean;
    actions?: ReactNode;
    onInvalidFormValidation?: () => unknown;
}
declare function Form({ onValid, onInvalid, fields, button, autofocus, mode, developerView, isDisabled, isFetching, actions, onInvalidFormValidation, }: FormProps): react_jsx_runtime.JSX.Element;

type FormFieldProps = Omit<FormControlProps, 'label'> & {
    label: ReactNode;
    description?: ReactNode;
    footerDescription?: ReactNode;
    helpText?: ReactNode;
    errorText?: ReactNode;
    tooltip?: ReactNode;
    _label?: FormLabelProps;
    _help?: FormHelperTextProps;
    _error?: FormErrorMessageProps;
    showRequiredIndicator?: boolean;
};
declare function FormField({ children, label, tooltip, description, footerDescription, isInvalid, helpText, errorText, _label, _help, _error, isRequired, showRequiredIndicator, ...props }: FormFieldProps): react_jsx_runtime.JSX.Element;

interface CopyButtonProps extends ButtonProps$1 {
    content: string;
    showLabel?: boolean;
    showIcon?: boolean;
    iconSize?: IconBaseProps['size'];
    customLabel?: string;
}
declare function CopyButton({ content, showLabel, showIcon, customLabel, iconSize, ...props }: CopyButtonProps): react_jsx_runtime.JSX.Element;

interface CodeBlockProps extends Omit<SyntaxHighlighterProps, 'children'> {
    language: string;
    codeString: string;
    highlightLines?: [number, number];
    removeLineBreaksFromCopy?: boolean;
    showLineNumbers?: boolean;
    showCopyButton?: boolean;
    /**
     * @deprecated this setting is no longer relevant, the scroll will appear if required
     */
    showScroll?: boolean;
    theme?: 'dark' | 'light';
}
declare function CodeBlock({ codeString, language, removeLineBreaksFromCopy, showLineNumbers, showCopyButton, highlightLines, theme, ...otherProps }: CodeBlockProps): react_jsx_runtime.JSX.Element;

type DataTableProps<T> = {
    variant?: 'simple' | 'default';
    columns: ColumnDef<T>[];
    data: T[];
    size?: 'sm' | 'md';
    showColumnSelector?: boolean;
    enableColumnFilters?: boolean;
    enableColumnResizing?: boolean;
    expandRowByClick?: boolean;
    rowSelection?: RowSelectionState;
    onRowSelectionChange?: OnChangeFn<RowSelectionState>;
    defaultPageSize?: 5 | 10 | 20 | 30 | 40 | 50 | 100;
    selectable?: boolean;
    emptyText?: string;
    emptyAction?: ReactElement<ButtonProps>;
    isLoading?: boolean;
    loadingText?: string;
    rowClassName?: (row: Row<T>) => string;
} & ({
    onRow?: (row: Row<T>) => void;
    subComponent?: never;
    getRowCanExpand?: never;
} | {
    onRow?: never;
    subComponent?: FC<{
        row: Row<T>;
    }>;
    getRowCanExpand?: (row: Row<T>) => boolean;
}) & ({
    pagination?: false;
    onPaginationChange?: never;
} | {
    pagination: true | PaginationState;
    onPaginationChange?: OnChangeFn<PaginationState>;
}) & ({
    sorting?: false;
    onSortingChange?: never;
} | {
    sorting: true | SortingState;
    onSortingChange?: OnChangeFn<SortingState>;
});
declare function DataTable<T>({ variant, columns, data, size, showColumnSelector, enableColumnFilters, enableColumnResizing, subComponent: SubComponent, expandRowByClick, selectable, rowSelection, onRowSelectionChange, defaultPageSize, sorting, onSortingChange, pagination, onPaginationChange, emptyText, emptyAction, isLoading, loadingText, onRow, rowClassName, getRowCanExpand, }: DataTableProps<T>): react_jsx_runtime.JSX.Element;

type ResourceListColumnProps = {
    key: string;
    content: ReactNode;
    width?: string;
    align?: GridProps['justifyContent'];
};
type ResourceListItemProps = {
    key: string;
    link?: string;
    onClick?: MouseEventHandler<HTMLDivElement>;
    [key: string]: ReactNode | MouseEventHandler<HTMLDivElement>;
    content?: string | ReactNode;
};
type ResourceListProps = {
    testId?: string;
    columns: ResourceListColumnProps[];
    rows: ResourceListItemProps[];
    alignSelf?: GridProps['alignSelf'];
    showColumns?: boolean;
    isExpandable?: boolean;
};
declare function ResourceList({ testId, columns, rows, alignSelf, showColumns, isExpandable, }: ResourceListProps): react_jsx_runtime.JSX.Element;

type SearchFieldProps = {
    setSearchText: (value: string) => void;
    searchText: string;
    placeholderText?: string;
    icon?: 'search' | 'filter';
    isDisabled?: boolean;
} & ChakraProps;
declare const SearchField: ({ setSearchText, searchText, placeholderText, icon, isDisabled, ...chakraProps }: SearchFieldProps) => react_jsx_runtime.JSX.Element;

interface NumberInputProps extends NumberInputProps$1 {
    name?: string;
    min?: number;
    max?: number;
    step?: number;
    value?: string | number;
    placeholder?: string;
    onChange: (valueAsString: string, valueAsNumber: number) => void;
    showIconButtons?: boolean;
}
declare const NumberInput: ({ placeholder, name, step, showIconButtons, ...props }: NumberInputProps) => react_jsx_runtime.JSX.Element;

interface PasswordInputProps extends InputProps {
    name?: string;
    defaultShowPassword?: boolean;
    showEyeIndicator?: boolean;
}
declare const PasswordInput: ({ name, defaultShowPassword, showEyeIndicator, ...props }: PasswordInputProps) => react_jsx_runtime.JSX.Element;

type Sizes = 'sm' | 'md' | 'lg';
type RadioCardProps = {
    isAttached?: boolean;
    direction?: StackProps['direction'];
    size: Sizes;
} & RadioProps;
declare function RadioCard(props: RadioCardProps): react_jsx_runtime.JSX.Element;

interface RadioGroupOption {
    value: RadioGroupProps$1['value'] | boolean | number | readonly string[];
    label: string | ReactNode;
    group?: string;
    disabled?: boolean;
    invalid?: boolean;
}
type RadioGroupCombinedProps = RadioGroup & UseRadioGroupProps;
type ControlledRadioGroup = RadioGroupCombinedProps & {
    defaultValue?: never;
};
type UncontrolledRadioGroup = RadioGroupCombinedProps & {
    value?: never;
};
type RadioGroupProps = (ControlledRadioGroup | UncontrolledRadioGroup) & {
    direction?: StackProps['direction'];
};
interface RadioGroup extends Omit<ControllerRenderProps<{
    [k: string]: any;
}, string>, 'ref' | 'onBlur' | 'value'> {
    options: RadioGroupOption[];
    isAttached?: boolean;
    size?: Sizes;
    onBlur?: FocusEventHandler<HTMLDivElement>;
    onClick?: MouseEventHandler<HTMLDivElement>;
}
declare function RadioGroup(props: RadioGroupProps): react_jsx_runtime.JSX.Element;

interface SelectOptionGroup<T = SelectFieldProps['value']> {
    label: string;
    options: SelectOption<T>[];
}
interface SelectOption<T = SelectFieldProps['value']> {
    value: T;
    label?: string | ReactNode;
    disabled?: boolean;
    invalid?: boolean;
}
interface SelectProps<T> extends Props<SelectOption<T>> {
    max?: number;
    options: SelectOption<T>[] | SelectOptionGroup<T>[];
    value?: PropsValue<SelectOption<T>>;
    defaultValue?: PropsValue<SelectOption<T>>;
    innerRef?: Ref<SelectInstance<SelectOption<T>, boolean, GroupBase<SelectOption<T>>>>;
    creatable?: boolean;
}
declare function isSingleValue<T>(option: MultiValue<SelectOption<T>> | SingleValue<SelectOption<T>>): option is SingleValue<SelectOption<T>>;
declare function isMultiValue<T>(option: MultiValue<SelectOption<T>> | SingleValue<SelectOption<T>>): option is SelectOption<T>[];
declare function isSingleSelectOptions<T>(options: SelectOption<T>[] | SelectOptionGroup<T>[]): options is SelectOption<T>[];
declare function isGroupSelectOptions<T>(options: SelectOption<T>[] | SelectOptionGroup<T>[]): options is SelectOptionGroup<T>[];
declare const Select: <T = string | number | readonly string[] | undefined>({ name, options, isMulti, max, hideSelectedOptions, classNames, chakraStyles, innerRef, defaultValue, value, formatGroupLabel, selectedOptionColorScheme, selectedOptionStyle, onMenuOpen, onMenuClose, closeMenuOnSelect, components, creatable, ...otherProps }: SelectProps<T>) => react_jsx_runtime.JSX.Element;

interface ColumnSelectOption extends Record<string, unknown> {
    label: string | ReactNode;
    value: SelectFieldProps['value'];
}
interface ColumnSelectProps extends SelectProps<SelectFieldProps['value']> {
    headerColumns: (string | ReactNode)[];
    singleValueText?: Record<string, string | ReactNode>;
    firstTextPosition?: 'left' | 'right';
    footer?: string | ReactNode;
}
declare const ColumnSelect: ({ headerColumns, singleValueText, firstTextPosition, footer, ...props }: ColumnSelectProps) => react_jsx_runtime.JSX.Element;

declare const TIMEZONE_OPTIONS: readonly ["Local", "UTC"];
type Timezone = (typeof TIMEZONE_OPTIONS)[number];
interface DateTimePickerProps extends Omit<ReactDatePickerProps, 'onChange'> {
    onChange: (value: Date | null, dateString: [string, string] | string, timezone: Timezone) => void;
    showTimezoneOptions?: boolean;
    showButtons?: boolean;
    defaultDate?: Date;
    defaultTimezone?: Timezone;
}
declare const DateTimePicker: ({ onChange, showTimezoneOptions, showButtons, showTimeSelect, showWeekNumbers, defaultDate, defaultTimezone, ...props }: DateTimePickerProps) => react_jsx_runtime.JSX.Element;

type DateTimeInputProps = {
    onChange: (value: number) => void;
    value: number;
};
declare const DateTimeInput: FC<DateTimeInputProps>;

interface DropzoneProps {
    setRawString: (value: string | undefined) => void;
    fileUploadLogo?: ReactNode;
    fileUploadText?: string | ReactNode;
    fileUploadDescription?: string | ReactNode;
    fileUploadedLogo?: ReactNode;
    fileUploadedText?: string | ReactNode;
    fileRemoveText?: string | ReactNode;
}
declare function Dropzone({ setRawString, fileUploadLogo, fileUploadText, fileUploadDescription, fileUploadedLogo, fileUploadedText, fileRemoveText, }: DropzoneProps): react_jsx_runtime.JSX.Element;

interface TooltipProps extends HTMLChakraProps<'div'>, ThemingProps<'Tooltip'>, UseTooltipProps {
    /**
     * The React component to use as the
     * trigger for the tooltip
     */
    children: React.ReactNode;
    /**
     * The label of the tooltip
     */
    label?: React.ReactNode;
    /**
     * The accessible, human friendly label to use for
     * screen readers.
     *
     * If passed, tooltip will show the content `label`
     * but expose only `aria-label` to assistive technologies
     */
    'aria-label'?: string;
    /**
     * If `true`, the tooltip will wrap its children
     * in a `<span/>` with `tabIndex=0`
     * @default false
     */
    shouldWrapChildren?: boolean;
    /**
     * If `true`, the tooltip will show an arrow tip
     * @default false
     */
    hasArrow?: boolean;
    /**
     * Props to be forwarded to the portal component
     */
    portalProps?: Pick<PortalProps, 'appendToParentPortal' | 'containerRef'>;
    motionProps?: HTMLMotionProps<'div'>;
    /**
     * Can only use when direction !== 'top'
     */
    arrowShadowColor?: string;
}

interface RPSliderMarkProps extends SliderMarkProps {
    label: string | ReactNode;
}
interface RPSliderProps extends SliderProps {
    marks?: RPSliderMarkProps[];
    sliderTooltip?: Omit<TooltipProps, 'children'>;
}
declare const RPSlider: ({ marks, name, sliderTooltip, ...rest }: RPSliderProps) => react_jsx_runtime.JSX.Element;

declare const BADGE_VARIANTS: readonly ["default", "inverted", "subtle", "outline", "info", "info-inverted", "info-outline", "error", "error-inverted", "error-outline", "success", "success-inverted", "success-outline", "warning", "warning-inverted", "warning-outline"];
type BadgeVariants = (typeof BADGE_VARIANTS)[number];
type BadgeProps = Omit<BadgeProps$1, 'variant'> & {
    variant?: BadgeVariants;
};
declare const Badge: _chakra_ui_system_dist_system_types.ComponentWithAs<"span", BadgeProps>;

interface AccordionItemProps extends AccordionItemProps$1 {
    heading: string | ReactNode;
    description: string | ReactNode;
}
interface AccordionProps extends AccordionProps$1 {
    items: AccordionItemProps[];
    /**
     * @description defaultIndex should be matching `allowMultiple`, either array like `[0]` or number `0`
     */
    defaultIndex?: number | number[];
    showCompleteStep?: boolean;
    nextStepText?: string | ReactNode;
    completedSteps?: number[];
    omitNextButton?: boolean;
}
declare const Accordion: ({ items, defaultIndex, allowToggle, allowMultiple, showCompleteStep, nextStepText, completedSteps, omitNextButton, ...rest }: AccordionProps) => react_jsx_runtime.JSX.Element;

interface AccordionIconProps {
    isComplete?: boolean;
}
declare const AccordionIcon: ({ isComplete }: AccordionIconProps) => react_jsx_runtime.JSX.Element;

interface CustomJsonViewerProps<Value> extends JsonViewerProps<Value> {
    defaultExpanded?: boolean;
}
declare function CustomJsonViewer<Value>(props: CustomJsonViewerProps<Value>): react_jsx_runtime.JSX.Element;

type MarkdownProps = Options & Omit<CodeBlockProps, 'language' | 'codeString'>;
declare const Markdown: ({ children, theme, ...otherProps }: MarkdownProps) => react_jsx_runtime.JSX.Element;

declare const _default: {
    babyYodaSvg: string;
    builderPandaSvg: string;
    cloudPandaNoTextSvg: string;
    cloudPandaTextOnlySvg: string;
    cloudPandaSvg: string;
    comparisonPandaCloudSvg: string;
    comparisonPandaSvg: string;
    devPandaFrontViewSvg: string;
    devPandaGlassesSvg: string;
    devPandaSvg: string;
    easyButtonSvg: string;
    errorBananaSlipSvg: string;
    errorSvg: string;
    labPandaStandingSvg: string;
    labPandaSvg: string;
    openHouseSvg: string;
    pandaFaceClosedEyesSvg: string;
    pandaFaceSvg: string;
    pouncingPandaSvg: string;
    redLeaderPandaAllSvg: string;
    redLeaderPandaFrontBlueSvg: string;
    redLeaderPandaFrontGreySvg: string;
    redLeaderPandaFrontRedSvg: string;
    redLeaderPandaFrontYellowSvg: string;
    redLeaderPandaHelmetOffSvg: string;
    redLeaderPandaMarchSvg: string;
    redLeaderPandaSvg: string;
    rocketPandaSvg: string;
    safariPandaNoCameraSvg: string;
    safariPandaSvg: string;
    sittingPandaSvg: string;
    skaterPandaSvg: string;
    superPandaBannerOpenHouseSvg: string;
    superPandaBannerRedpandaOpenHouseSvg: string;
    superPandaSvg: string;
    tcoPandaNoHelmetSvg: string;
    tcoPandaSvg: string;
    teacherPandaSvg: string;
    wavingPandaSvg: string;
    xWingClosedSvg: string;
    xWingSvg: string;
    yogaPandaOpenEyesSvg: string;
    yogaPandaSvg: string;
    treadmillPandaSvg: string;
    loadingTreadmillPandaSvg: string;
    jugglingPandaSvg: string;
    jugglingPandaBallSvg: string;
    devPandaRearViewSvg: string;
    newsPandaSvg: string;
    newsPandaFrontSvg: string;
    barBellPandaSunglassesSvg: string;
    barBellPandaSvg: string;
    graduatePandaSvg: string;
    graduatePandaWithLogoSvg: string;
    jetpackPandaLeftStraightSvg: string;
    jetpackPandaLeftSvg: string;
    jetpackPandaFrontSvg: string;
    uploadFileSvg: string;
    dedicatedIconSvg: string;
    bringYourOwnCloudIconSvg: string;
    serverlessIconSvg: string;
    googleIconSvg: string;
    githubIconSvg: string;
    oktaSvg: string;
    emailSvg: string;
    auth0Svg: string;
};

interface ResultProps {
    status?: 'success' | 'warning' | 'error' | number;
    redpandaErrorCode?: number;
    userMessage?: string | ReactNode;
    title: string | ReactNode;
    subTitle?: string | ReactNode;
    extra?: ReactNode;
}
declare const Result: ({ status, ...props }: ResultProps) => react_jsx_runtime.JSX.Element;

interface EmptyProps {
    errorCode?: number;
    description?: string | ReactNode;
}
/**
 * TODO: Update copy once finalized
 * @see https://docs.google.com/document/d/1lsVy4Nh7XUy7IfLGgS5_yAzc_KfWq7FN4lweEeKhaTs/edit#heading=h.wtmcurv0whje
 */
declare const Empty: ({ errorCode, description }: EmptyProps) => react_jsx_runtime.JSX.Element;

type ForbidProps<T> = {
    [P in keyof T]?: never;
};
type RenderFunction = () => React__default.ReactNode;
type OptionalContentProps = {
    title?: React__default.ReactNode | RenderFunction;
    content: React__default.ReactNode | RenderFunction;
    hideCloseButton?: boolean;
    hasArrow?: boolean;
    isInPortal?: boolean;
};
type PopoverProps = PopoverProps$1 & (OptionalContentProps | ForbidProps<OptionalContentProps>);
declare const Popover: _chakra_ui_system_dist_system_types.ComponentWithAs<"section", PopoverProps>;

type PopoverContentProps = PropsWithChildren<PopoverContentProps$1> & {
    isInPortal?: boolean;
};
declare const PopoverContent: _chakra_ui_system_dist_system_types.ComponentWithAs<"section", PopoverContentProps>;

interface TextDividerProps extends GridProps {
    text: string | ReactNode;
    textColor?: TextProps['color'];
    lineColor?: BoxProps['bg'];
    lineHeight?: BoxProps['height'];
}
declare const TextDivider: ({ lineColor, lineHeight, textColor, text, ...props }: TextDividerProps) => react_jsx_runtime.JSX.Element;

declare const Spinner: (props: SpinnerProps) => react_jsx_runtime.JSX.Element;

interface Auth0ButtonProps extends ButtonProps {
    provider: string;
}
declare const Auth0Button: ({ provider, children, ...rest }: Auth0ButtonProps) => react_jsx_runtime.JSX.Element;

interface Auth0ModalHeaderProps extends ModalHeaderProps {
    withLogo?: boolean;
}
declare const Auth0ModalHeader: ({ children, withLogo, ...props }: Auth0ModalHeaderProps) => react_jsx_runtime.JSX.Element;

interface Auth0InputProps extends InputProps {
    placeholder?: string;
}
declare const Auth0Input: ({ ...props }: Auth0InputProps) => react_jsx_runtime.JSX.Element;

interface Auth0ModalProps {
    children: string | ReactNode;
    minHeight?: BoxProps['minHeight'];
    imageURL?: string;
}
declare const Auth0Modal: ({ children, minHeight, imageURL, }: Auth0ModalProps) => react_jsx_runtime.JSX.Element;

declare const Auth0ModalBody: ({ children, ...props }: ModalBodyProps) => react_jsx_runtime.JSX.Element;

declare const Auth0ModalDescription: ({ children, ...props }: TextProps) => react_jsx_runtime.JSX.Element;

declare const Auth0Divider: ({ ...props }: TextDividerProps) => react_jsx_runtime.JSX.Element;

declare const Auth0ModalHeading: ({ children, ...props }: HeadingProps$1) => react_jsx_runtime.JSX.Element;

declare const Auth0ModalLink: _chakra_ui_system_dist_system_types.ComponentWithAs<"a", LinkProps>;

declare const Auth0ModalText: ({ children, ...props }: TextProps) => react_jsx_runtime.JSX.Element;

declare const Auth0SubmitButton: ({ children, ...rest }: ButtonProps$1) => react_jsx_runtime.JSX.Element;

declare const EnabledIcon: ({ ...props }: IconProps) => react_jsx_runtime.JSX.Element;

declare const DisabledIcon: ({ ...props }: IconProps) => react_jsx_runtime.JSX.Element;

type Strategy = 'oidc' | 'auth0' | 'google-oauth2' | 'github' | 'google' | 'okta' | 'Username-Password-Authentication';

interface ProviderImageProps extends ImageProps {
    provider: Strategy;
}
declare const ProviderImage: ({ provider, ...imageProps }: ProviderImageProps) => react_jsx_runtime.JSX.Element;

export { Accordion, AccordionIcon, Auth0Button, Auth0Divider, Auth0ModalHeader as Auth0Header, Auth0Input, Auth0Modal, Auth0ModalBody, Auth0ModalDescription, Auth0ModalHeading, Auth0ModalLink, Auth0ModalText, Auth0SubmitButton, _default as Avatars, Badge, type BadgeProps, BaseLayout, BaseModal, Breadcrumbs, Button, type ButtonProps, CodeBlock, ColorModeSwitch, ColumnSelect, type ColumnSelectOption, type ColumnSelectProps, ConfirmItemDeleteModal, ConfirmModal, type ConfirmModalProps, CopyButton, type CustomFormSectionProps, DataTable, DateTimeInput, DateTimePicker, DisabledIcon, Dropzone, Empty, EnabledIcon, Form, FormField, FormProvider, Heading, CustomJsonViewer as JsonViewer, Logo, Markdown, Nav, NavLink, NumberInput, PasswordInput, Popover, PopoverContent, ProviderImage, RPSlider, RadioCard, RadioGroup, ResourceList, Result, SearchField, Section, SectionDivider, SectionHeading, SectionSubheading, Select, Sidebar, Spinner, Steps, Tabs, TextDivider, colors, components, isGroupSelectOptions, isMultiValue, isSingleSelectOptions, isSingleValue, theme as redpandaTheme, toastOptions as redpandaToastOptions, styles, useConfirmModal, type useConfirmModalProps, useKey, useLocalStorage, useReactHookForm, useSynchronizedAnimation };
