import * as react from 'react';
import { CSSProperties, ReactNode, HTMLAttributes, ComponentPropsWithoutRef, ReactElement, ElementType, ComponentPropsWithRef, ComponentProps } from 'react';
import { DisclosureProps, DisclosureGroupProps, DisclosurePanelProps, HeadingProps, ButtonProps as ButtonProps$1, DatePickerProps as DatePickerProps$1, DateRangePickerProps as DateRangePickerProps$1, ModalOverlayProps, DialogTriggerProps as DialogTriggerProps$1, TabProps as TabProps$1, TabListProps as TabListProps$1, TabPanelProps as TabPanelProps$1, TabsProps as TabsProps$1, LinkProps as LinkProps$1, CheckboxProps as CheckboxProps$1, CheckboxGroupProps as CheckboxGroupProps$1, Key, ComboBoxProps, ListBoxItemRenderProps, ListBoxItemProps, RadioProps as RadioProps$1, RadioGroupProps as RadioGroupProps$1, SliderProps as SliderProps$1, CellProps as CellProps$1, ColumnProps as ColumnProps$1, RowProps as RowProps$1, TableProps as TableProps$1, TableBodyProps as TableBodyProps$1, TableHeaderProps as TableHeaderProps$1, TagProps as TagProps$1, TagListProps, TagGroupProps as TagGroupProps$1, TextFieldProps as TextFieldProps$1, NumberFieldProps as NumberFieldProps$1, TooltipProps as TooltipProps$1, TooltipTriggerComponentProps, PopoverProps as PopoverProps$1, MenuProps as MenuProps$1, ListBoxProps, MenuItemProps as MenuItemProps$1, MenuSectionProps as MenuSectionProps$1, SeparatorProps, MenuTriggerProps as MenuTriggerProps$1, SubmenuTriggerProps as SubmenuTriggerProps$1, SearchFieldProps as SearchFieldProps$1, GridListProps, GridListItemProps, SelectProps as SelectProps$1, SwitchProps as SwitchProps$1, ToggleButtonProps as ToggleButtonProps$1, ToggleButtonGroupProps as ToggleButtonGroupProps$1 } from 'react-aria-components';
import { DateValue } from '@internationalized/date';
import * as react_jsx_runtime from 'react/jsx-runtime';
import { NavigateOptions } from 'react-router-dom';
import { AsyncListData } from 'react-stately/useAsyncList';
export { useAsyncList } from 'react-stately/useAsyncList';
import { ColumnSize, ColumnStaticSize, SortDescriptor as SortDescriptor$1 } from 'react-stately';

/** @public */
type Breakpoint = 'initial' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
/** @public */
type Responsive<T> = T | Partial<Record<Breakpoint, T>>;
/** @public */
type Space = '0.5' | '1' | '1.5' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | '10' | '11' | '12' | '13' | '14' | string;
/** @public */
type Display = 'none' | 'flex' | 'block' | 'inline';
/** @public */
type FlexDirection = 'row' | 'column';
/** @public */
type FlexWrap = 'wrap' | 'nowrap' | 'wrap-reverse';
/** @public */
type JustifyContent = 'stretch' | 'start' | 'center' | 'end' | 'around' | 'between';
/** @public */
type AlignItems = 'stretch' | 'start' | 'center' | 'end';
/** @public */
type BorderRadius = 'none' | '2xs' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
/**
 * Border variants available for UI utility props.
 *
 * @public
 */
type Border = 'none' | 'base' | 'error' | 'warning' | 'selected';
/** @public */
type Columns = '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | '10' | '11' | '12' | 'auto';
/** @public */
interface MarginProps {
    m?: Responsive<Space>;
    mb?: Responsive<Space>;
    ml?: Responsive<Space>;
    mr?: Responsive<Space>;
    mt?: Responsive<Space>;
    mx?: Responsive<Space>;
    my?: Responsive<Space>;
}
/** @public */
interface PaddingProps {
    p?: Responsive<Space>;
    pb?: Responsive<Space>;
    pl?: Responsive<Space>;
    pr?: Responsive<Space>;
    pt?: Responsive<Space>;
    px?: Responsive<Space>;
    py?: Responsive<Space>;
}
/** @public */
interface SpaceProps extends MarginProps, PaddingProps {
}
/**
 * Flex item properties.
 *
 * @public
 */
interface FlexItemProps {
    /** Controls the flex-grow property. Values of `true` or `false` are converted to `1` or `0` respectively. */
    grow?: Responsive<number | boolean>;
    /** Controls the flex-shrink property. Values of `true` or `false` are converted to `1` or `0` respectively. */
    shrink?: Responsive<number | boolean>;
    /** Controls the flex-basis property. */
    basis?: Responsive<CSSProperties['flexBasis']>;
}
/** @public */
type TextVariants = 'title-large' | 'title-medium' | 'title-small' | 'title-x-small' | 'body-large' | 'body-medium' | 'body-small' | 'body-x-small';
/** @public */
type TextColors = 'primary' | 'secondary';
/** @public */
type TextColorStatus = 'danger' | 'warning' | 'success' | 'info';
/** @public */
type TextWeights = 'regular' | 'bold';
/**
 * Shared utility props supported by layout-oriented UI components.
 *
 * @public
 */
interface UtilityProps extends SpaceProps {
    /** Aligns children on the cross axis in flex and grid layouts. */
    alignItems?: Responsive<AlignItems>;
    /** Applies a semantic border variant. */
    border?: Responsive<Border>;
    /** Applies a semantic border radius token. */
    borderRadius?: Responsive<BorderRadius>;
    /** Sets the ending grid column line. */
    colEnd?: Responsive<Columns | 'auto'>;
    /** Sets the number of grid columns to span. */
    colSpan?: Responsive<Columns | 'full'>;
    /** Sets the starting grid column line. */
    colStart?: Responsive<Columns | 'auto'>;
    /** Sets the number of columns for grid containers. */
    columns?: Responsive<Columns>;
    /** Controls the CSS display value. */
    display?: Responsive<Display>;
    /** Controls the direction of flex items. */
    flexDirection?: Responsive<FlexDirection>;
    /** Controls how flex items wrap. */
    flexWrap?: Responsive<FlexWrap>;
    /** Sets spacing between children in flex and grid layouts. */
    gap?: Responsive<Space>;
    /** Aligns children on the main axis in flex and grid layouts. */
    justifyContent?: Responsive<JustifyContent>;
    /** Sets the number of grid rows to span. */
    rowSpan?: Responsive<Columns | 'full'>;
}
/**
 * Resolved background level stored in context and applied as `data-bg` on DOM elements.
 * Background type for the neutral bg system.
 *
 * Supports neutral levels ('neutral-1' through 'neutral-3') and
 * intent backgrounds ('danger', 'warning', 'success').
 *
 * The 'neutral-4' level is not exposed as a prop value -- it is reserved
 * for leaf component CSS (e.g. Button on a 'neutral-3' surface).
 *
 * This is the resolved/internal representation used by the bg context system.
 * For the prop type accepted by container components, use `ProviderBg` instead.
 *
 * @public
 */
type ContainerBg = 'neutral-1' | 'neutral-2' | 'neutral-3' | 'danger' | 'warning' | 'success';
/**
 * Background values accepted by provider components (Box, Flex, Grid, Card, etc.).
 *
 * - `'neutral'` — automatically increments the neutral level from the parent context,
 *   capping at the maximum level. This is always incremental; explicit levels cannot
 *   be set directly.
 * - `'danger'` | `'warning'` | `'success'` — intent backgrounds used as-is.
 *
 * @public
 */
type ProviderBg = 'neutral' | 'danger' | 'warning' | 'success';

/** @public */
type BoxOwnProps = {
    as?: keyof JSX.IntrinsicElements;
    bg?: Responsive<ProviderBg>;
    children: ReactNode;
    className?: string;
    style?: CSSProperties;
};
/** @public */
type BoxUtilityProps = {
    display?: Responsive<'none' | 'flex' | 'block' | 'inline'>;
    position?: Responsive<'static' | 'relative' | 'absolute' | 'fixed' | 'sticky'>;
    width?: Responsive<string>;
    minWidth?: Responsive<string>;
    maxWidth?: Responsive<string>;
    height?: Responsive<string>;
    minHeight?: Responsive<string>;
    maxHeight?: Responsive<string>;
};
/** @public */
interface BoxProps extends SpaceProps, FlexItemProps, BoxOwnProps, BoxUtilityProps, Omit<React.HTMLAttributes<HTMLDivElement>, 'children'> {
}

/**
 * A general-purpose layout primitive that can render as any HTML element and supports spacing, sizing, and background props.
 *
 * @public
 */
declare const Box: react.ForwardRefExoticComponent<BoxProps & react.RefAttributes<HTMLDivElement>>;

/**
 * Component definition for Box
 * @public
 */
declare const BoxDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-Box";
    };
    readonly bg: "provider";
    readonly propDefs: {
        readonly as: {
            readonly default: "div";
        };
        readonly bg: {
            readonly dataAttribute: true;
        };
        readonly children: {};
        readonly className: {};
        readonly style: {};
    };
    readonly utilityProps: readonly ["m", "mb", "ml", "mr", "mt", "mx", "my", "p", "pb", "pl", "pr", "pt", "px", "py", "position", "display", "grow", "shrink", "basis", "width", "minWidth", "maxWidth", "height", "minHeight", "maxHeight"];
};

/** @public */
type GridOwnProps = {
    children: ReactNode;
    className?: string;
    style?: CSSProperties;
    bg?: Responsive<ProviderBg>;
};
/** @public */
interface GridProps extends SpaceProps, FlexItemProps, GridOwnProps, Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
    columns?: Responsive<Columns>;
    gap?: Responsive<Space>;
}
/** @public */
type GridItemOwnProps = {
    children: ReactNode;
    className?: string;
    style?: CSSProperties;
    bg?: Responsive<ProviderBg>;
};
/** @public */
interface GridItemProps extends GridItemOwnProps, Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
    colSpan?: Responsive<Columns>;
    colEnd?: Responsive<Columns>;
    colStart?: Responsive<Columns>;
    rowSpan?: Responsive<Columns>;
}

/** @public */
declare const Grid: {
    Root: react.ForwardRefExoticComponent<GridProps & react.RefAttributes<HTMLDivElement>>;
    Item: react.ForwardRefExoticComponent<GridItemProps & react.RefAttributes<HTMLDivElement>>;
};

/**
 * Component definition for Grid
 * @public
 */
declare const GridDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-Grid";
    };
    readonly bg: "provider";
    readonly propDefs: {
        readonly bg: {
            readonly dataAttribute: true;
        };
        readonly children: {};
        readonly className: {};
        readonly style: {};
    };
    readonly utilityProps: readonly ["columns", "gap", "m", "mb", "ml", "mr", "mt", "mx", "my", "p", "pb", "pl", "pr", "pt", "px", "py", "grow", "shrink", "basis"];
};
/**
 * Component definition for GridItem
 * @public
 */
declare const GridItemDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-GridItem";
    };
    readonly bg: "provider";
    readonly propDefs: {
        readonly bg: {
            readonly dataAttribute: true;
        };
        readonly children: {};
        readonly className: {};
        readonly style: {};
    };
    readonly utilityProps: readonly ["colSpan", "colEnd", "colStart", "rowSpan"];
};

/** @public */
type FlexOwnProps = {
    children: ReactNode;
    className?: string;
    style?: CSSProperties;
    bg?: Responsive<ProviderBg>;
};
/** @public */
interface FlexProps extends SpaceProps, FlexItemProps, FlexOwnProps, Omit<React.HTMLAttributes<HTMLDivElement>, 'children'> {
    gap?: Responsive<Space>;
    align?: Responsive<'start' | 'center' | 'end' | 'baseline' | 'stretch'>;
    justify?: Responsive<'start' | 'center' | 'end' | 'between'>;
    direction?: Responsive<'row' | 'column' | 'row-reverse' | 'column-reverse'>;
}

/**
 * A flexbox layout container with props for controlling gap, alignment, justification, and direction.
 *
 * @public
 */
declare const Flex: react.ForwardRefExoticComponent<FlexProps & react.RefAttributes<HTMLDivElement>>;

/**
 * Component definition for Flex
 * @public
 */
declare const FlexDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-Flex";
    };
    readonly bg: "provider";
    readonly propDefs: {
        readonly bg: {
            readonly dataAttribute: true;
        };
        readonly children: {};
        readonly className: {};
        readonly style: {};
    };
    readonly utilityProps: readonly ["m", "mb", "ml", "mr", "mt", "mx", "my", "p", "pb", "pl", "pr", "pt", "px", "py", "gap", "align", "justify", "direction", "grow", "shrink", "basis"];
};

/** @public */
type ContainerOwnProps = {
    children?: React.ReactNode;
    className?: string;
    style?: React.CSSProperties;
};
/** @public */
interface ContainerProps extends ContainerOwnProps, Omit<React.ComponentPropsWithoutRef<'div'>, keyof ContainerOwnProps> {
    my?: SpaceProps['my'];
    mb?: SpaceProps['mb'];
    mt?: SpaceProps['mt'];
    py?: SpaceProps['py'];
    pb?: SpaceProps['pb'];
    pt?: SpaceProps['pt'];
}

/**
 * A centered layout wrapper that constrains content to a maximum width and provides consistent page-level padding.
 *
 * @public
 */
declare const Container: react.ForwardRefExoticComponent<ContainerProps & react.RefAttributes<HTMLDivElement>>;

/**
 * Component definition for Container
 * @public
 */
declare const ContainerDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-Container";
    };
    readonly propDefs: {
        readonly children: {};
        readonly className: {};
        readonly style: {};
    };
    readonly utilityProps: readonly ["my", "mt", "mb", "py", "pt", "pb", "display"];
};

/** @public */
type FullPageOwnProps = {
    className?: string;
};
/**
 * Props for the FullPage component.
 *
 * @public
 */
interface FullPageProps extends Omit<ComponentPropsWithoutRef<'main'>, 'className'>, FullPageOwnProps {
}

/**
 * A component that fills the remaining viewport height below the Header.
 *
 * The FullPage component consumes the `--bui-header-height` CSS custom property
 * set by the Header component to calculate its height as
 * `calc(100dvh - var(--bui-header-height, 0px))`. Content inside the FullPage
 * scrolls independently while the Header stays visible.
 *
 * @public
 */
declare const FullPage: react.ForwardRefExoticComponent<FullPageProps & react.RefAttributes<HTMLElement>>;

/**
 * Component definition for FullPage
 * @public
 */
declare const FullPageDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-FullPage";
    };
    readonly propDefs: {
        readonly className: {};
    };
};

/**
 * Own props for the Accordion component.
 * @public
 */
type AccordionOwnProps = {
    bg?: ProviderBg;
    children: ReactNode;
    className?: string;
};
/**
 * Props for the Accordion component.
 * @public
 */
interface AccordionProps extends Omit<DisclosureProps, 'children' | 'className'>, AccordionOwnProps {
}
/**
 * Own props for the AccordionTrigger component.
 * @public
 */
type AccordionTriggerOwnProps = {
    className?: string;
    title?: string;
    subtitle?: string;
    children?: ReactNode;
};
/**
 * Props for the AccordionTrigger component.
 * @public
 */
interface AccordionTriggerProps extends Omit<HeadingProps, 'children' | 'className'>, AccordionTriggerOwnProps {
}
/**
 * Own props for the AccordionPanel component.
 * @public
 */
type AccordionPanelOwnProps = {
    className?: string;
};
/**
 * Props for the AccordionPanel component.
 * @public
 */
interface AccordionPanelProps extends Omit<DisclosurePanelProps, 'className'>, AccordionPanelOwnProps {
}
/**
 * Own props for the AccordionGroup component.
 * @public
 */
type AccordionGroupOwnProps = {
    className?: string;
    /**
     * Whether multiple accordions can be expanded at the same time.
     * @defaultValue false
     */
    allowsMultiple?: boolean;
};
/**
 * Props for the AccordionGroup component.
 * @public
 */
interface AccordionGroupProps extends Omit<DisclosureGroupProps, 'className'>, AccordionGroupOwnProps {
}

/**
 * A collapsible section that reveals or hides its content when the trigger is activated.
 *
 * @public
 */
declare const Accordion: react.ForwardRefExoticComponent<AccordionProps & react.RefAttributes<HTMLDivElement>>;
/**
 * The clickable heading that toggles the visibility of an accordion panel.
 *
 * @public
 */
declare const AccordionTrigger: react.ForwardRefExoticComponent<AccordionTriggerProps & react.RefAttributes<HTMLHeadingElement>>;
/**
 * The content area of an accordion that is revealed when the trigger is activated.
 *
 * @public
 */
declare const AccordionPanel: react.ForwardRefExoticComponent<AccordionPanelProps & react.RefAttributes<HTMLDivElement>>;
/**
 * A container that groups multiple Accordion items, optionally allowing several panels to be expanded at once.
 *
 * @public
 */
declare const AccordionGroup: react.ForwardRefExoticComponent<AccordionGroupProps & react.RefAttributes<HTMLDivElement>>;

/**
 * Component definition for Accordion
 * @public
 */
declare const AccordionDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-Accordion";
    };
    readonly bg: "provider";
    readonly propDefs: {
        readonly bg: {
            readonly dataAttribute: true;
            readonly default: "neutral";
        };
        readonly children: {};
        readonly className: {};
    };
};
/**
 * Component definition for AccordionTrigger
 * @public
 */
declare const AccordionTriggerDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-AccordionTrigger";
        readonly button: "bui-AccordionTriggerButton";
        readonly title: "bui-AccordionTriggerTitle";
        readonly subtitle: "bui-AccordionTriggerSubtitle";
        readonly icon: "bui-AccordionTriggerIcon";
    };
    readonly propDefs: {
        readonly className: {};
        readonly title: {};
        readonly subtitle: {};
        readonly children: {};
    };
};
/**
 * Component definition for AccordionPanel
 * @public
 */
declare const AccordionPanelDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-AccordionPanel";
    };
    readonly propDefs: {
        readonly className: {};
    };
};
/**
 * Component definition for AccordionGroup
 * @public
 */
declare const AccordionGroupDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-AccordionGroup";
    };
    readonly propDefs: {
        readonly className: {};
        readonly allowsMultiple: {
            readonly default: false;
        };
    };
};

/** @public */
type AlertOwnProps = {
    status?: Responsive<'info' | 'success' | 'warning' | 'danger'>;
    icon?: boolean | ReactElement;
    isPending?: boolean;
    /** @deprecated Use `isPending` instead. */
    loading?: boolean;
    customActions?: ReactNode;
    title?: ReactNode;
    description?: ReactNode;
    className?: string;
    style?: CSSProperties;
};
/**
 * Properties for {@link Alert}
 *
 * @public
 */
interface AlertProps extends MarginProps, AlertOwnProps, Omit<React.ComponentPropsWithoutRef<'div'>, keyof AlertOwnProps | keyof MarginProps> {
}

/**
 * A component for displaying alert messages with different status levels.
 *
 * @remarks
 * The Alert component supports multiple status variants (info, success, warning, danger)
 * and can display icons, pending states, and custom actions. It automatically handles
 * icon selection based on status when the icon prop is set to true.
 *
 * @example
 * Basic usage with title only:
 * ```tsx
 * <Alert status="info" title="This is an informational message" />
 * ```
 *
 * @example
 * With title and description:
 * ```tsx
 * <Alert
 *   status="warning"
 *   icon={true}
 *   title="Pending Review"
 *   description="Please review the following items before proceeding."
 * />
 * ```
 *
 * @example
 * With custom actions and pending state:
 * ```tsx
 * <Alert
 *   status="success"
 *   icon={true}
 *   title="Operation completed"
 *   description="Your changes have been saved successfully."
 *   isPending={isProcessing}
 *   customActions={
 *     <>
 *       <Button size="small" variant="tertiary">Dismiss</Button>
 *       <Button size="small" variant="primary">View</Button>
 *     </>
 *   }
 * />
 * ```
 *
 * @public
 */
declare const Alert: react.ForwardRefExoticComponent<AlertProps & react.RefAttributes<HTMLDivElement>>;

/**
 * Component definition for Alert
 * @public
 */
declare const AlertDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-Alert";
        readonly contentWrapper: "bui-AlertContentWrapper";
        readonly content: "bui-AlertContent";
        readonly title: "bui-AlertTitle";
        readonly description: "bui-AlertDescription";
        readonly icon: "bui-AlertIcon";
        readonly spinner: "bui-AlertSpinner";
        readonly actions: "bui-AlertActions";
    };
    readonly propDefs: {
        readonly status: {
            readonly dataAttribute: true;
            readonly default: "info";
        };
        readonly isPending: {
            readonly dataAttribute: true;
        };
        readonly loading: {
            readonly dataAttribute: true;
        };
        readonly icon: {};
        readonly customActions: {};
        readonly title: {};
        readonly description: {};
        readonly className: {};
        readonly style: {};
    };
    readonly utilityProps: readonly ["m", "mb", "ml", "mr", "mt", "mx", "my"];
};

/** @public */
type AvatarOwnProps = {
    /**
     * URL of the image to display
     */
    src: string;
    /**
     * Name of the person - used for generating initials and accessibility labels
     */
    name: string;
    /**
     * Size of the avatar
     * @defaultValue 'medium'
     */
    size?: 'x-small' | 'small' | 'medium' | 'large' | 'x-large';
    /**
     * Determines how the avatar is presented to assistive technologies.
     * - 'informative': Avatar is announced as "\{name\}" to screen readers
     * - 'decoration': Avatar is hidden from screen readers (use when name appears in adjacent text)
     * @defaultValue 'informative'
     */
    purpose?: 'decoration' | 'informative';
    className?: string;
};
/** @public */
interface AvatarProps extends Omit<React.ComponentPropsWithoutRef<'div'>, 'children' | 'className'>, AvatarOwnProps {
}

/**
 * Displays a user's profile image with an automatic fallback to their initials when the image fails to load.
 *
 * @public
 */
declare const Avatar: react.ForwardRefExoticComponent<AvatarProps & react.RefAttributes<HTMLDivElement>>;

/**
 * Component definition for Avatar
 * @public
 */
declare const AvatarDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-AvatarRoot";
        readonly image: "bui-AvatarImage";
        readonly fallback: "bui-AvatarFallback";
    };
    readonly propDefs: {
        readonly size: {
            readonly dataAttribute: true;
            readonly default: "medium";
        };
        readonly purpose: {
            readonly default: "informative";
        };
        readonly src: {};
        readonly name: {};
        readonly className: {};
    };
};

/**
 * Own props for the Badge component.
 *
 * @public
 */
type BadgeOwnProps = {
    /**
     * The icon to display before the badge text.
     */
    icon?: React.ReactNode;
    /**
     * The size of the badge.
     */
    size?: 'small' | 'medium';
    children?: React.ReactNode;
    className?: string;
};
/**
 * Props for the Badge component.
 *
 * @public
 */
interface BadgeProps extends BadgeOwnProps, Omit<React.HTMLAttributes<HTMLSpanElement>, keyof BadgeOwnProps> {
}

/**
 * A non-interactive badge for labeling or categorizing content.
 *
 * @public
 */
declare const Badge: react.ForwardRefExoticComponent<BadgeProps & react.RefAttributes<HTMLSpanElement>>;

/**
 * Component definition for Badge
 * @public
 */
declare const BadgeDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-Badge";
        readonly icon: "bui-BadgeIcon";
    };
    readonly bg: "consumer";
    readonly propDefs: {
        readonly icon: {};
        readonly size: {
            readonly dataAttribute: true;
            readonly default: "small";
        };
        readonly children: {};
        readonly className: {};
    };
};

/** @public */
type ButtonOwnProps = {
    size?: Responsive<'small' | 'medium'>;
    variant?: Responsive<'primary' | 'secondary' | 'tertiary'>;
    destructive?: boolean;
    iconStart?: ReactElement;
    iconEnd?: ReactElement;
    isPending?: boolean;
    /** @deprecated Use `isPending` instead. */
    loading?: boolean;
    children?: ReactNode;
    className?: string;
};
/**
 * Properties for {@link Button}
 *
 * @public
 */
interface ButtonProps extends Omit<ButtonProps$1, keyof ButtonOwnProps>, ButtonOwnProps {
}

/**
 * A button component built on React Aria Components that provides accessible
 * interactive elements for triggering actions.
 *
 * @remarks
 * The Button component supports multiple variants (primary, secondary, tertiary, danger),
 * sizes (small, medium), and states including loading and disabled. It automatically
 * handles keyboard navigation, focus management, and ARIA attributes for accessibility.
 *
 * @example
 * Basic usage:
 * ```tsx
 * <Button>Click me</Button>
 * ```
 *
 * @example
 * With icons and loading state:
 * ```tsx
 * <Button
 *   variant="primary"
 *   size="medium"
 *   iconStart={<IconComponent />}
 *   isPending={isSubmitting}
 * >
 *   Submit
 * </Button>
 * ```
 *
 * @public
 */
declare const Button: react.ForwardRefExoticComponent<ButtonProps & react.RefAttributes<HTMLButtonElement>>;

/**
 * Component definition for Button
 * @public
 */
declare const ButtonDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-Button";
        readonly content: "bui-ButtonContent";
        readonly spinner: "bui-ButtonSpinner";
    };
    readonly bg: "consumer";
    readonly propDefs: {
        readonly size: {
            readonly dataAttribute: true;
            readonly default: "small";
        };
        readonly variant: {
            readonly dataAttribute: true;
            readonly default: "primary";
        };
        readonly destructive: {
            readonly dataAttribute: true;
        };
        readonly isPending: {
            readonly dataAttribute: true;
        };
        readonly loading: {
            readonly dataAttribute: true;
        };
        readonly iconStart: {};
        readonly iconEnd: {};
        readonly children: {};
        readonly className: {};
    };
};

/** @public */
type CardBaseProps = {
    children?: ReactNode;
    className?: string;
    style?: CSSProperties;
};
/** @public */
type CardButtonVariant = {
    /** Handler called when the card is pressed. Makes the card interactive as a button. */
    onPress: NonNullable<ButtonProps$1['onPress']>;
    href?: never;
    /** Accessible label announced by screen readers for the interactive card. */
    label: string;
    target?: never;
    rel?: never;
    download?: never;
};
/** @public */
type CardLinkVariant = {
    /** URL to navigate to. Makes the card interactive as a link. */
    href: string;
    onPress?: never;
    /** Accessible label announced by screen readers for the interactive card. */
    label: string;
    /** Specifies where to open the linked URL (e.g. `_blank` for a new tab). */
    target?: string;
    /** Relationship between the current document and the linked URL (e.g. `noopener`). */
    rel?: string;
    /** Prompts the user to save the linked URL. Pass `true` for default filename or a string for a custom filename. */
    download?: boolean | string;
};
/** @public */
type CardStaticVariant = {
    onPress?: never;
    href?: never;
    label?: never;
    target?: never;
    rel?: never;
    download?: never;
};
/**
 * Props for the Card component.
 *
 * @public
 */
type CardProps = CardBaseProps & FlexItemProps & Omit<React.HTMLAttributes<HTMLDivElement>, 'onClick'> & (CardButtonVariant | CardLinkVariant | CardStaticVariant);
/**
 * Flat own-props shape used by the component definition system.
 * Derived from the Card variant types so it automatically stays in sync with CardProps.
 * @public
 */
type CardOwnProps = Pick<CardBaseProps & (CardButtonVariant | CardLinkVariant | CardStaticVariant), 'children' | 'className' | 'onPress' | 'href' | 'label' | 'target' | 'rel' | 'download' | 'style'>;
/** @public */
type CardHeaderOwnProps = {
    children?: ReactNode;
    className?: string;
};
/**
 * Props for the CardHeader component.
 *
 * @public
 */
interface CardHeaderProps extends CardHeaderOwnProps, React.HTMLAttributes<HTMLDivElement> {
}
/** @public */
type CardBodyOwnProps = {
    children?: ReactNode;
    className?: string;
};
/**
 * Props for the CardBody component.
 *
 * @public
 */
interface CardBodyProps extends CardBodyOwnProps, React.HTMLAttributes<HTMLDivElement> {
}
/** @public */
type CardFooterOwnProps = {
    children?: ReactNode;
    className?: string;
};
/**
 * Props for the CardFooter component.
 *
 * @public
 */
interface CardFooterProps extends CardFooterOwnProps, React.HTMLAttributes<HTMLDivElement> {
}

/**
 * Card component.
 *
 * @public
 */
declare const Card: react.ForwardRefExoticComponent<CardProps & react.RefAttributes<HTMLDivElement>>;
/**
 * CardHeader component.
 *
 * @public
 */
declare const CardHeader: react.ForwardRefExoticComponent<CardHeaderProps & react.RefAttributes<HTMLDivElement>>;
/**
 * CardBody component.
 *
 * @public
 */
declare const CardBody: react.ForwardRefExoticComponent<CardBodyProps & react.RefAttributes<HTMLDivElement>>;
/**
 * CardFooter component.
 *
 * @public
 */
declare const CardFooter: react.ForwardRefExoticComponent<CardFooterProps & react.RefAttributes<HTMLDivElement>>;

/**
 * Component definition for Card
 * @public
 */
declare const CardDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-Card";
        readonly trigger: "bui-CardTrigger";
    };
    readonly propDefs: {
        readonly children: {};
        readonly className: {};
        readonly onPress: {};
        readonly href: {};
        readonly label: {};
        readonly target: {};
        readonly rel: {};
        readonly download: {};
        readonly style: {};
    };
    readonly utilityProps: readonly ["grow", "shrink", "basis"];
};
/**
 * Component definition for CardHeader
 * @public
 */
declare const CardHeaderDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-CardHeader";
    };
    readonly propDefs: {
        readonly children: {};
        readonly className: {};
    };
};
/**
 * Component definition for CardBody
 * @public
 */
declare const CardBodyDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-CardBody";
    };
    readonly propDefs: {
        readonly children: {};
        readonly className: {};
    };
};
/**
 * Component definition for CardFooter
 * @public
 */
declare const CardFooterDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-CardFooter";
    };
    readonly propDefs: {
        readonly children: {};
        readonly className: {};
    };
};

/** @public */
type FieldLabelOwnProps = {
    /**
     * The label of the text field
     */
    label?: string | null;
    /**
     * The secondary label of the text field
     */
    secondaryLabel?: string | null;
    /**
     * The description of the text field
     */
    description?: string | null;
    /**
     * The HTML for attribute of the text field
     */
    htmlFor?: string;
    /**
     * The id of the text field
     */
    id?: string;
    /**
     * The id to apply to the description element for aria-describedby
     */
    descriptionId?: string;
    /**
     * The slot name to set on the description's React Aria `<Text>` element.
     */
    descriptionSlot?: string;
    className?: string;
};
/** @public */
interface FieldLabelProps extends FieldLabelOwnProps, Omit<React.ComponentPropsWithoutRef<'div'>, keyof FieldLabelOwnProps> {
}

/** @public */
type DatePickerOwnProps = {
    /**
     * The size of the date picker
     * @defaultValue 'small'
     */
    size?: 'small' | 'medium' | Partial<Record<Breakpoint, 'small' | 'medium'>>;
    className?: string;
    label?: FieldLabelProps['label'];
    description?: FieldLabelProps['description'];
    secondaryLabel?: FieldLabelProps['secondaryLabel'];
};
/** @public */
interface DatePickerProps extends Omit<DatePickerProps$1<DateValue>, 'className' | 'children'>, DatePickerOwnProps {
}

/**
 * A date picker that combines a date field and a calendar popover, allowing
 * users to enter or select a date with full keyboard and screen reader
 * accessibility.
 *
 * @public
 */
declare const DatePicker: react.ForwardRefExoticComponent<DatePickerProps & react.RefAttributes<HTMLDivElement>>;

/**
 * Component definition for DatePicker
 * @public
 */
declare const DatePickerDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-DatePicker";
    };
    readonly propDefs: {
        readonly size: {
            readonly dataAttribute: true;
            readonly default: "small";
        };
        readonly className: {};
        readonly label: {};
        readonly description: {};
        readonly secondaryLabel: {};
    };
};
/**
 * Component definition for DatePickerGroup
 * @public
 */
declare const DatePickerGroupDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-DatePickerGroup";
        readonly dateInput: "bui-DatePickerDateInput";
        readonly segment: "bui-DatePickerSegment";
        readonly button: "bui-DatePickerButton";
    };
    readonly bg: "consumer";
    readonly propDefs: {};
};
/**
 * Component definition for DatePickerCalendar
 * @public
 */
declare const DatePickerCalendarDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-DatePickerCalendar";
        readonly header: "bui-DatePickerCalendarHeader";
        readonly heading: "bui-DatePickerCalendarHeading";
        readonly navButton: "bui-DatePickerCalendarNavButton";
        readonly grid: "bui-DatePickerCalendarGrid";
        readonly gridHeader: "bui-DatePickerCalendarGridHeader";
        readonly headerCell: "bui-DatePickerCalendarHeaderCell";
        readonly gridBody: "bui-DatePickerCalendarGridBody";
        readonly cell: "bui-DatePickerCalendarCell";
    };
    readonly propDefs: {};
};

/** @public */
type DateRangePickerOwnProps = {
    /**
     * The size of the date range picker
     * @defaultValue 'small'
     */
    size?: 'small' | 'medium' | Partial<Record<Breakpoint, 'small' | 'medium'>>;
    className?: string;
    label?: FieldLabelProps['label'];
    description?: FieldLabelProps['description'];
    secondaryLabel?: FieldLabelProps['secondaryLabel'];
};
/** @public */
interface DateRangePickerProps extends Omit<DateRangePickerProps$1<DateValue>, 'className' | 'children'>, DateRangePickerOwnProps {
}

/**
 * A date range picker that combines two date fields and a calendar popover,
 * allowing users to enter or select a date range with full keyboard and
 * screen reader accessibility.
 *
 * @public
 */
declare const DateRangePicker: react.ForwardRefExoticComponent<DateRangePickerProps & react.RefAttributes<HTMLDivElement>>;

/**
 * Component definition for DateRangePicker
 * @public
 */
declare const DateRangePickerDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-DateRangePicker";
    };
    readonly propDefs: {
        readonly size: {
            readonly dataAttribute: true;
            readonly default: "small";
        };
        readonly className: {};
        readonly label: {};
        readonly description: {};
        readonly secondaryLabel: {};
    };
};

/**
 * Props for the DialogTrigger component.
 * @public
 */
interface DialogTriggerProps extends DialogTriggerProps$1 {
}
/** @public */
type DialogOwnProps = {
    children?: ReactNode;
    className?: string;
    width?: number | string;
    height?: number | string;
    style?: React.CSSProperties;
};
/**
 * Props for the Dialog component.
 * @public
 */
interface DialogProps extends DialogOwnProps, Omit<ModalOverlayProps, keyof DialogOwnProps> {
}
/** @public */
type DialogHeaderOwnProps = {
    children?: ReactNode;
    className?: string;
};
/**
 * Props for the DialogHeader component.
 * @public
 */
interface DialogHeaderProps extends DialogHeaderOwnProps, Omit<HeadingProps, keyof DialogHeaderOwnProps> {
}
/** @public */
type DialogBodyOwnProps = {
    children?: ReactNode;
    className?: string;
};
/**
 * Props for the DialogBody component.
 * @public
 */
interface DialogBodyProps extends DialogBodyOwnProps, Omit<React.ComponentPropsWithoutRef<'div'>, keyof DialogBodyOwnProps> {
}
/** @public */
type DialogFooterOwnProps = {
    children?: ReactNode;
    className?: string;
};
/**
 * Props for the DialogFooter component.
 * @public
 */
interface DialogFooterProps extends DialogFooterOwnProps, Omit<React.ComponentPropsWithoutRef<'div'>, keyof DialogFooterOwnProps> {
}

/**
 * A wrapper that connects a trigger element to a Dialog, controlling its open and close state.
 *
 * @public
 */
declare const DialogTrigger: (props: DialogTriggerProps) => react_jsx_runtime.JSX.Element;
/**
 * A modal overlay that presents content requiring user interaction or acknowledgment, dismissible by clicking outside or pressing Escape.
 *
 * @public
 */
declare const Dialog: react.ForwardRefExoticComponent<DialogProps & react.RefAttributes<HTMLDivElement>>;
/**
 * The header section of a Dialog, containing the title and a close button.
 *
 * @public
 */
declare const DialogHeader: react.ForwardRefExoticComponent<DialogHeaderProps & react.RefAttributes<HTMLDivElement>>;
/**
 * The main scrollable content area of a Dialog.
 *
 * @public
 */
declare const DialogBody: react.ForwardRefExoticComponent<DialogBodyProps & react.RefAttributes<HTMLDivElement>>;
/**
 * The footer section of a Dialog, typically used to place action buttons.
 *
 * @public
 */
declare const DialogFooter: react.ForwardRefExoticComponent<DialogFooterProps & react.RefAttributes<HTMLDivElement>>;

/**
 * Component definition for Dialog
 * @public
 */
declare const DialogDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-DialogOverlay";
        readonly container: "bui-Dialog";
        readonly inner: "bui-DialogInner";
        readonly content: "bui-DialogContent";
    };
    readonly propDefs: {
        readonly children: {};
        readonly className: {};
        readonly width: {};
        readonly height: {};
        readonly style: {};
    };
};
/**
 * Component definition for DialogHeader
 * @public
 */
declare const DialogHeaderDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-DialogHeader";
        readonly title: "bui-DialogHeaderTitle";
    };
    readonly propDefs: {
        readonly children: {};
        readonly className: {};
    };
};
/**
 * Component definition for DialogBody
 * @public
 */
declare const DialogBodyDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-DialogBody";
    };
    readonly propDefs: {
        readonly children: {};
        readonly className: {};
    };
};
/**
 * Component definition for DialogFooter
 * @public
 */
declare const DialogFooterDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-DialogFooter";
    };
    readonly propDefs: {
        readonly children: {};
        readonly className: {};
    };
};

/**
 * Renders a label for a form field with optional secondary label and description text.
 *
 * @public
 */
declare const FieldLabel: react.ForwardRefExoticComponent<FieldLabelProps & react.RefAttributes<HTMLDivElement>>;

/**
 * Component definition for FieldLabel
 * @public
 */
declare const FieldLabelDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-FieldLabelWrapper";
        readonly label: "bui-FieldLabel";
        readonly secondaryLabel: "bui-FieldSecondaryLabel";
        readonly description: "bui-FieldDescription";
    };
    readonly propDefs: {
        readonly label: {};
        readonly secondaryLabel: {};
        readonly description: {};
        readonly htmlFor: {};
        readonly id: {};
        readonly descriptionId: {};
        readonly descriptionSlot: {};
        readonly className: {};
    };
};

/**
 * Strategies for matching the current route to determine which tab should be active.
 *
 * @public
 */
type TabMatchStrategy = 'exact' | 'prefix';
/**
 * Own props for the Tabs component.
 *
 * @public
 */
type TabsOwnProps = {
    className?: string;
    children?: TabsProps$1['children'];
};
/**
 * Props for the Tabs component.
 *
 * @public
 */
interface TabsProps extends TabsOwnProps, Omit<TabsProps$1, keyof TabsOwnProps> {
}
/**
 * Own props for the TabList component.
 *
 * @public
 */
type TabListOwnProps = {
    className?: string;
    children?: TabListProps$1<object>['children'];
};
/**
 * Props for the TabList component.
 *
 * @public
 */
interface TabListProps extends TabListOwnProps, Omit<TabListProps$1<object>, 'items' | keyof TabListOwnProps> {
}
/**
 * Own props for the Tab component.
 *
 * @public
 */
type TabOwnProps = {
    className?: string;
    /**
     * Strategy for matching the current route to determine if this tab should be active.
     * - 'exact': Tab href must exactly match the current pathname (default)
     * - 'prefix': Tab is active if current pathname starts with tab href
     */
    matchStrategy?: TabMatchStrategy;
    href?: TabProps$1['href'];
    id?: TabProps$1['id'];
    noTrack?: boolean;
};
/**
 * Props for the Tab component.
 *
 * @public
 */
interface TabProps extends TabOwnProps, Omit<TabProps$1, keyof TabOwnProps> {
}
/**
 * Own props for the TabPanel component.
 *
 * @public
 */
type TabPanelOwnProps = {
    className?: string;
};
/**
 * Props for the TabPanel component.
 *
 * @public
 */
interface TabPanelProps extends TabPanelOwnProps, Omit<TabPanelProps$1, keyof TabPanelOwnProps> {
}

/**
 * A component that renders a list of tabs.
 *
 * @public
 */
declare const Tabs: (props: TabsProps) => react_jsx_runtime.JSX.Element | null;
/**
 * A component that renders a list of tabs.
 *
 * @public
 */
declare const TabList: (props: TabListProps) => react_jsx_runtime.JSX.Element;
/**
 * A component that renders a tab.
 *
 * @public
 */
declare const Tab: (props: TabProps) => react_jsx_runtime.JSX.Element;
/**
 * A component that renders the content of a tab.
 *
 * @public
 */
declare const TabPanel: (props: TabPanelProps) => react_jsx_runtime.JSX.Element;

/**
 * Component definition for Tabs
 * @public
 */
declare const TabsDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-Tabs";
    };
    readonly propDefs: {
        readonly className: {};
        readonly children: {};
    };
};

/**
 * Own props for the {@link PluginHeader} component.
 *
 * @public
 */
interface PluginHeaderOwnProps {
    icon?: React.ReactNode;
    title?: string;
    titleLink?: string;
    customActions?: React.ReactNode;
    tabs?: HeaderTab[];
    onTabSelectionChange?: TabsProps$1['onSelectionChange'];
    className?: string;
}
/**
 * Props for the {@link PluginHeader} component.
 *
 * @public
 */
interface PluginHeaderProps extends PluginHeaderOwnProps {
}
/**
 * Represents a tab item in the header navigation.
 *
 * @public
 */
interface HeaderTab {
    id: string;
    label: string;
    href: string;
    /**
     * Strategy for matching the current route to determine if this tab should be active.
     * - 'exact': Tab href must exactly match the current pathname (default)
     * - 'prefix': Tab is active if current pathname starts with tab href
     */
    matchStrategy?: TabMatchStrategy;
}

declare module 'react-aria-components' {
    interface RouterConfig {
        routerOptions: NavigateOptions;
    }
}
/**
 * Renders a plugin header with icon, title, custom actions, and optional tabs.
 * Always participates in the background context system so descendants (e.g. buttons)
 * get the correct `data-on-bg` styling inside the toolbar and tabs.
 *
 * @public
 */
declare const PluginHeader: (props: PluginHeaderProps) => react_jsx_runtime.JSX.Element;

/**
 * Component definition for PluginHeader
 * @public
 */
declare const PluginHeaderDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-PluginHeader";
        readonly toolbar: "bui-PluginHeaderToolbar";
        readonly toolbarContent: "bui-PluginHeaderToolbarContent";
        readonly toolbarControls: "bui-PluginHeaderToolbarControls";
        readonly toolbarIcon: "bui-PluginHeaderToolbarIcon";
        readonly toolbarName: "bui-PluginHeaderToolbarName";
        readonly tabs: "bui-PluginHeaderTabsWrapper";
    };
    readonly propDefs: {
        readonly icon: {};
        readonly title: {};
        readonly titleLink: {};
        readonly customActions: {};
        readonly tabs: {};
        readonly onTabSelectionChange: {};
        readonly className: {};
    };
};

/**
 * Represents a single navigation tab in the header.
 *
 * @public
 */
interface HeaderNavTab {
    id: string;
    label: string;
    href: string;
}
/**
 * Represents a group of navigation tabs rendered as a dropdown menu.
 *
 * @public
 */
interface HeaderNavTabGroup {
    id: string;
    label: string;
    items: HeaderNavTab[];
}
/**
 * A navigation tab item — either a flat link or a dropdown group.
 *
 * @public
 */
type HeaderNavTabItem = HeaderNavTab | HeaderNavTabGroup;
/**
 * Represents a tag item in the header.
 *
 * @public
 */
interface HeaderTag {
    label: string;
    href?: string;
}
/**
 * Represents a metadata key-value pair in the header.
 *
 * @public
 */
interface HeaderMetadataItem {
    label: string;
    value: React.ReactNode;
}
/**
 * Represents a user in the HeaderMetadataUsers component.
 *
 * @public
 */
interface HeaderMetadataUser {
    name: string;
    src?: string;
    href?: string;
}
/**
 * Represents a status item in the HeaderMetadataStatus component.
 *
 * @public
 */
interface HeaderMetadataStatusProps {
    label: string;
    color: 'danger' | 'warning' | 'success' | 'info';
    href?: string;
}
/**
 * Own props for the Header component.
 *
 * @public
 */
interface HeaderOwnProps {
    title?: string;
    customActions?: React.ReactNode;
    tabs?: HeaderNavTabItem[];
    activeTabId?: string | null;
    /**
     * @deprecated The breadcrumbs prop will be removed in a future release.
     */
    breadcrumbs?: HeaderBreadcrumb[];
    /**
     * Markdown string rendered below the title. Only inline links are supported.
     * Bold, italic, and block-level markdown are not rendered.
     */
    description?: string;
    tags?: HeaderTag[];
    metadata?: HeaderMetadataItem[];
    className?: string;
    /**
     * Makes the title-and-actions row stick to the top of its nearest scroll
     * container while the rest of the header content scrolls away.
     */
    sticky?: boolean;
}
/**
 * Props for the Header component.
 *
 * @public
 */
interface HeaderProps extends HeaderOwnProps {
}
/**
 * Represents a breadcrumb item in the header.
 *
 * @public
 */
interface HeaderBreadcrumb {
    label: string;
    href: string;
}
/**
 * @public
 * @deprecated Use {@link HeaderOwnProps} instead.
 */
type HeaderPageOwnProps = HeaderOwnProps;
/**
 * @public
 * @deprecated Use {@link HeaderProps} instead.
 */
type HeaderPageProps = HeaderProps;
/**
 * @public
 * @deprecated Use {@link HeaderBreadcrumb} instead.
 */
type HeaderPageBreadcrumb = HeaderBreadcrumb;

/**
 * A secondary header with title, breadcrumbs, tabs, and actions.
 *
 * @public
 */
declare const Header: (props: HeaderProps) => react_jsx_runtime.JSX.Element;
/**
 * @public
 * @deprecated Use {@link Header} instead.
 */
declare const HeaderPage: (props: HeaderProps) => react_jsx_runtime.JSX.Element;

/**
 * Component definition for Header
 * @public
 */
declare const HeaderDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly bg: "consumer";
    readonly classNames: {
        readonly headerTop: "bui-HeaderTop";
        readonly stickySentinel: "bui-HeaderStickySentinel";
        readonly content: "bui-HeaderContent";
        readonly headerBottom: "bui-HeaderBottom";
        readonly breadcrumbs: "bui-HeaderBreadcrumbs";
        readonly breadcrumbsSmall: "bui-HeaderBreadcrumbsSmall";
        readonly breadcrumbLink: "bui-HeaderBreadcrumbLink";
        readonly breadcrumbLinkSmall: "bui-HeaderBreadcrumbLinkSmall";
        readonly breadcrumbSeparator: "bui-HeaderBreadcrumbSeparator";
        readonly titleStack: "bui-HeaderTitleStack";
        readonly title: "bui-HeaderTitle";
        readonly titleSmall: "bui-HeaderTitleSmall";
        readonly tabsWrapper: "bui-HeaderTabsWrapper";
        readonly controls: "bui-HeaderControls";
        readonly tags: "bui-HeaderTags";
        readonly tag: "bui-HeaderTag";
        readonly description: "bui-HeaderDescription";
        readonly metaRow: "bui-HeaderMetaRow";
        readonly metaItem: "bui-HeaderMetaItem";
    };
    readonly propDefs: {
        readonly title: {};
        readonly customActions: {};
        readonly tabs: {};
        readonly activeTabId: {};
        readonly breadcrumbs: {};
        readonly description: {};
        readonly tags: {};
        readonly metadata: {};
        readonly className: {};
        readonly sticky: {};
    };
};
/**
 * @public
 * @deprecated Use {@link HeaderDefinition} instead.
 */
declare const HeaderPageDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly bg: "consumer";
    readonly classNames: {
        readonly headerTop: "bui-HeaderTop";
        readonly stickySentinel: "bui-HeaderStickySentinel";
        readonly content: "bui-HeaderContent";
        readonly headerBottom: "bui-HeaderBottom";
        readonly breadcrumbs: "bui-HeaderBreadcrumbs";
        readonly breadcrumbsSmall: "bui-HeaderBreadcrumbsSmall";
        readonly breadcrumbLink: "bui-HeaderBreadcrumbLink";
        readonly breadcrumbLinkSmall: "bui-HeaderBreadcrumbLinkSmall";
        readonly breadcrumbSeparator: "bui-HeaderBreadcrumbSeparator";
        readonly titleStack: "bui-HeaderTitleStack";
        readonly title: "bui-HeaderTitle";
        readonly titleSmall: "bui-HeaderTitleSmall";
        readonly tabsWrapper: "bui-HeaderTabsWrapper";
        readonly controls: "bui-HeaderControls";
        readonly tags: "bui-HeaderTags";
        readonly tag: "bui-HeaderTag";
        readonly description: "bui-HeaderDescription";
        readonly metaRow: "bui-HeaderMetaRow";
        readonly metaItem: "bui-HeaderMetaItem";
    };
    readonly propDefs: {
        readonly title: {};
        readonly customActions: {};
        readonly tabs: {};
        readonly activeTabId: {};
        readonly breadcrumbs: {};
        readonly description: {};
        readonly tags: {};
        readonly metadata: {};
        readonly className: {};
        readonly sticky: {};
    };
};

/** @public */
declare const HeaderNavDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-HeaderNav";
        readonly list: "bui-HeaderNavList";
        readonly active: "bui-HeaderNavActive";
        readonly hovered: "bui-HeaderNavHovered";
    };
    readonly propDefs: {
        readonly tabs: {};
        readonly activeTabId: {};
        readonly children: {};
        readonly className: {};
    };
};
/** @public */
declare const HeaderNavItemDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-HeaderNavItem";
    };
    readonly analytics: true;
    readonly propDefs: {
        readonly noTrack: {};
        readonly id: {};
        readonly label: {};
        readonly href: {};
        readonly active: {};
        readonly registerRef: {};
        readonly onHighlight: {};
        readonly className: {};
    };
};
/** @public */
declare const HeaderNavGroupDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-HeaderNavGroup";
    };
    readonly propDefs: {
        readonly className: {};
    };
};

/**
 * Displays a list of users as avatars inside a Header metadata value.
 * A single user shows the avatar with their name beside it.
 * Multiple users show avatars in a row with the name revealed on hover via tooltip.
 * When a user has an `href`, the avatar and name become links.
 *
 * @public
 */
declare const HeaderMetadataUsers: ({ users, }: {
    users: HeaderMetadataUser[];
}) => react_jsx_runtime.JSX.Element | null;

/**
 * Displays a single status indicator as a coloured dot with a label inside a
 * Header metadata value. Optionally renders the label as a link when href is provided.
 *
 * @public
 */
declare const HeaderMetadataStatus: ({ label, color, href, }: HeaderMetadataStatusProps) => react_jsx_runtime.JSX.Element;

/** @public */
type ButtonIconOwnProps = {
    size?: Responsive<'small' | 'medium'>;
    variant?: Responsive<'primary' | 'secondary' | 'tertiary'>;
    icon?: ReactElement;
    isPending?: boolean;
    /** @deprecated Use `isPending` instead. */
    loading?: boolean;
    className?: string;
};
/**
 * Properties for {@link ButtonIcon}
 *
 * @public
 */
interface ButtonIconProps extends Omit<ButtonProps$1, keyof ButtonIconOwnProps>, ButtonIconOwnProps {
}

/**
 * An icon-only button that supports a loading state and requires an accessible label.
 *
 * @public
 */
declare const ButtonIcon: react.ForwardRefExoticComponent<ButtonIconProps & react.RefAttributes<HTMLButtonElement>>;

/**
 * Component definition for ButtonIcon
 * @public
 */
declare const ButtonIconDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-ButtonIcon";
        readonly content: "bui-ButtonIconContent";
        readonly spinner: "bui-ButtonIconSpinner";
    };
    readonly bg: "consumer";
    readonly propDefs: {
        readonly size: {
            readonly dataAttribute: true;
            readonly default: "small";
        };
        readonly variant: {
            readonly dataAttribute: true;
            readonly default: "primary";
        };
        readonly isPending: {
            readonly dataAttribute: true;
        };
        readonly loading: {
            readonly dataAttribute: true;
        };
        readonly icon: {};
        readonly className: {};
    };
};

/** @public */
type ButtonLinkOwnProps = {
    noTrack?: boolean;
    size?: Responsive<'small' | 'medium'>;
    variant?: Responsive<'primary' | 'secondary' | 'tertiary'>;
    iconStart?: ReactElement;
    iconEnd?: ReactElement;
    children?: ReactNode;
    className?: string;
};
/**
 * Properties for {@link ButtonLink}
 *
 * @public
 */
interface ButtonLinkProps extends Omit<LinkProps$1, keyof ButtonLinkOwnProps>, ButtonLinkOwnProps {
}

/**
 * A button-styled anchor element for navigation, supporting optional start and end icon slots and analytics event tracking.
 *
 * @public
 */
declare const ButtonLink: react.ForwardRefExoticComponent<ButtonLinkProps & react.RefAttributes<HTMLAnchorElement>>;

/**
 * Component definition for ButtonLink
 * @public
 */
declare const ButtonLinkDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-ButtonLink";
        readonly content: "bui-ButtonLinkContent";
    };
    readonly bg: "consumer";
    readonly analytics: true;
    readonly propDefs: {
        readonly noTrack: {};
        readonly size: {
            readonly dataAttribute: true;
            readonly default: "small";
        };
        readonly variant: {
            readonly dataAttribute: true;
            readonly default: "primary";
        };
        readonly iconStart: {};
        readonly iconEnd: {};
        readonly children: {};
        readonly className: {};
    };
};

/** @public */
type CheckboxOwnProps = {
    children?: React.ReactNode;
    className?: string;
};
/** @public */
interface CheckboxProps extends Omit<CheckboxProps$1, 'children' | 'className'>, CheckboxOwnProps {
}

/**
 * A form checkbox input with support for indeterminate state and accessible labeling.
 *
 * @public
 */
declare const Checkbox: react.ForwardRefExoticComponent<CheckboxProps & react.RefAttributes<HTMLLabelElement>>;

/**
 * Component definition for Checkbox
 * @public
 */
declare const CheckboxDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-Checkbox";
        readonly indicator: "bui-CheckboxIndicator";
    };
    readonly propDefs: {
        readonly children: {};
        readonly className: {};
    };
};

/**
 * Own props for the CheckboxGroup component.
 * @public
 */
type CheckboxGroupOwnProps = {
    className?: string;
    children?: ReactNode;
    label?: FieldLabelProps['label'];
    secondaryLabel?: FieldLabelProps['secondaryLabel'];
    description?: FieldLabelProps['description'];
    isRequired?: CheckboxGroupProps$1['isRequired'];
    orientation?: 'horizontal' | 'vertical';
};
/**
 * Props for the CheckboxGroup component.
 * @public
 */
interface CheckboxGroupProps extends Omit<CheckboxGroupProps$1, keyof CheckboxGroupOwnProps>, CheckboxGroupOwnProps {
}

/**
 * A group of checkboxes for selecting multiple options from a list.
 * @public
 */
declare const CheckboxGroup: react.ForwardRefExoticComponent<CheckboxGroupProps & react.RefAttributes<HTMLDivElement>>;

/**
 * Component definition for CheckboxGroup
 * @public
 */
declare const CheckboxGroupDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-CheckboxGroup";
        readonly content: "bui-CheckboxGroupContent";
    };
    readonly propDefs: {
        readonly className: {};
        readonly children: {};
        readonly label: {};
        readonly secondaryLabel: {};
        readonly description: {};
        readonly isRequired: {};
        readonly orientation: {};
    };
};

/** @public */
type LoadingState = AsyncListData<unknown>['loadingState'];
/** @public */
type AsyncListSource<T> = Pick<AsyncListData<T>, 'items' | 'filterText' | 'setFilterText' | 'loadingState' | 'loadMore'>;
/** @public */
type LoadingConfig = {
    state: LoadingState;
    onLoadMore?: () => void;
};
/** @public */
type IdentifiedOption = {
    id: string;
    value?: never;
    label: string;
    description?: string;
    leadingIcon?: ReactNode;
    disabled?: boolean;
};
/** @public */
type LegacyOption = {
    /** @deprecated Use id instead. */
    value: string;
    id?: never;
    label: string;
    description?: never;
    leadingIcon?: never;
    disabled?: boolean;
};
/** @public */
type Option = IdentifiedOption | LegacyOption;
/** @public */
type OptionSection = {
    title: string;
    options: Option[];
};
/** @public */
type NormalizedOption = Omit<IdentifiedOption, 'value'>;

/** @public */
type ComboboxServerItem = {
    id: Key;
    textValue: string;
};
/** @public */
type ComboboxSearch<T> = true | {
    mode?: 'client';
    inputValue?: never;
    defaultInputValue?: string;
    onInputChange?: (value: string) => void;
    filter?: (item: T, query: string) => boolean;
} | {
    mode?: 'client';
    inputValue: string;
    defaultInputValue?: never;
    onInputChange: (value: string) => void;
    filter?: (item: T, query: string) => boolean;
} | {
    mode: 'server';
    inputValue: string;
    defaultInputValue?: never;
    onInputChange: (value: string) => void;
    filter?: never;
};
/** @public */
type ComboboxAsyncSearch<T> = true | {
    mode?: 'client';
    inputValue?: never;
    defaultInputValue?: string;
    onInputChange?: (value: string) => void;
    filter?: (item: T, query: string) => boolean;
} | {
    mode?: 'client';
    inputValue: string;
    defaultInputValue?: never;
    onInputChange: (value: string) => void;
    filter?: (item: T, query: string) => boolean;
} | {
    mode: 'server';
    inputValue?: never;
    defaultInputValue?: never;
    onInputChange?: never;
    filter?: never;
};
/** @public */
type ComboboxStaticSearch = true | {
    mode?: 'client';
    inputValue?: never;
    defaultInputValue?: string;
    onInputChange?: (value: string) => void;
    filter?: never;
} | {
    mode?: 'client';
    inputValue: string;
    defaultInputValue?: never;
    onInputChange: (value: string) => void;
    filter?: never;
};
/** @public */
type ComboboxBaseOwnProps = {
    /**
     * An icon to render before the input
     */
    icon?: ReactNode;
    /**
     * The size of the combobox field
     * @defaultValue 'small'
     */
    size?: 'small' | 'medium' | Partial<Record<Breakpoint, 'small' | 'medium'>>;
    /**
     * Placeholder text for the input.
     */
    placeholder?: string;
    label?: FieldLabelProps['label'];
    secondaryLabel?: FieldLabelProps['secondaryLabel'];
    description?: FieldLabelProps['description'];
    isRequired?: boolean;
    className?: string;
};
/** @public */
type ComboboxOwnProps<T extends {
    id: Key;
} = NormalizedOption> = ComboboxBaseOwnProps & {
    options?: ReadonlyArray<Option | OptionSection> | AsyncListSource<IdentifiedOption>;
    items?: Iterable<T> | AsyncListSource<T>;
    children?: ReactElement | ReactElement[] | ((item: T) => ReactElement);
    dependencies?: ReadonlyArray<unknown>;
    search?: ComboboxSearch<T> | ComboboxAsyncSearch<T>;
    loading?: LoadingConfig;
};
/** @public */
type ComboboxCommonProps<T extends {
    id: Key;
}> = ComboboxBaseOwnProps & Omit<ComboBoxProps<T>, keyof ComboboxOwnProps<T> | 'defaultItems' | 'inputValue' | 'defaultInputValue' | 'onInputChange' | 'defaultFilter' | 'value' | 'defaultValue' | 'onChange' | 'selectedKey' | 'defaultSelectedKey' | 'onSelectionChange'>;
/** @public */
type ComboboxKeySelectionProps<T extends {
    id: Key;
}> = Pick<ComboBoxProps<T>, 'value' | 'defaultValue' | 'onChange' | 'selectedKey' | 'defaultSelectedKey' | 'onSelectionChange'>;
/** @public */
type ComboboxItemSelectionProps<T extends {
    id: Key;
}> = {
    value?: T | null;
    defaultValue?: T | null;
    onChange?: (value: T | null) => void;
    selectedKey?: never;
    defaultSelectedKey?: never;
    onSelectionChange?: never;
};
/** @public */
type ComboboxOptionsProps = ComboboxCommonProps<NormalizedOption> & {
    options?: ReadonlyArray<Option | OptionSection>;
    items?: never;
    children?: never;
    dependencies?: never;
    loading?: LoadingConfig;
} & ({
    search?: ComboboxSearch<NormalizedOption>;
    inputValue?: never;
    defaultInputValue?: never;
    onInputChange?: never;
    defaultFilter?: never;
} | {
    search?: never;
    /** @deprecated Use search.inputValue instead. */
    inputValue?: string;
    /** @deprecated Use search.defaultInputValue instead. */
    defaultInputValue?: string;
    /** @deprecated Use search.onInputChange instead. */
    onInputChange?: (value: string) => void;
    /** @deprecated Use search.filter instead. */
    defaultFilter?: (textValue: string, inputValue: string) => boolean;
}) & ComboboxKeySelectionProps<NormalizedOption>;
/** @public */
type ComboboxAsyncOptionsProps = ComboboxCommonProps<NormalizedOption> & {
    options: AsyncListSource<IdentifiedOption>;
    items?: never;
    children?: never;
    dependencies?: never;
    loading?: never;
    search?: Exclude<ComboboxAsyncSearch<NormalizedOption>, {
        mode: 'server';
    }>;
    inputValue?: never;
    defaultInputValue?: never;
    onInputChange?: never;
    defaultFilter?: never;
} & ComboboxKeySelectionProps<NormalizedOption>;
/** @public */
type ComboboxItemsProps<T extends {
    id: Key;
}> = ComboboxCommonProps<T> & {
    options?: never;
    items: Iterable<T>;
    children: (item: T) => ReactElement;
    dependencies?: ReadonlyArray<unknown>;
    loading?: LoadingConfig;
    search?: ComboboxSearch<T>;
    inputValue?: never;
    defaultInputValue?: never;
    onInputChange?: never;
    defaultFilter?: never;
} & ComboboxKeySelectionProps<T>;
/** @public */
type ComboboxAsyncItemsProps<T extends {
    id: Key;
}> = ComboboxCommonProps<T> & {
    options?: never;
    items: AsyncListSource<T>;
    children: (item: T) => ReactElement;
    dependencies?: ReadonlyArray<unknown>;
    loading?: never;
    search?: Exclude<ComboboxAsyncSearch<T>, {
        mode: 'server';
    }>;
    inputValue?: never;
    defaultInputValue?: never;
    onInputChange?: never;
    defaultFilter?: never;
} & ComboboxKeySelectionProps<T>;
/** @public */
type ComboboxStaticProps = ComboboxCommonProps<NormalizedOption> & {
    options?: never;
    items?: never;
    children: ReactElement | ReactElement[];
    dependencies?: never;
    loading?: never;
    search?: ComboboxStaticSearch;
    inputValue?: never;
    defaultInputValue?: never;
    onInputChange?: never;
    defaultFilter?: never;
} & ComboboxKeySelectionProps<NormalizedOption>;
/** @public */
type ComboboxServerOptionsProps = ComboboxCommonProps<IdentifiedOption> & {
    options: AsyncListSource<IdentifiedOption>;
    items?: never;
    children?: never;
    dependencies?: never;
    loading?: never;
    search: Extract<ComboboxAsyncSearch<never>, {
        mode: 'server';
    }>;
    inputValue?: never;
    defaultInputValue?: never;
    onInputChange?: never;
    defaultFilter?: never;
} & ComboboxItemSelectionProps<IdentifiedOption>;
/** @public */
type ComboboxServerItemsProps<T extends ComboboxServerItem> = ComboboxCommonProps<T> & {
    options?: never;
    items: AsyncListSource<T>;
    children: (item: T) => ReactElement;
    dependencies?: ReadonlyArray<unknown>;
    loading?: never;
    search: Extract<ComboboxAsyncSearch<never>, {
        mode: 'server';
    }>;
    inputValue?: never;
    defaultInputValue?: never;
    onInputChange?: never;
    defaultFilter?: never;
} & ComboboxItemSelectionProps<T>;
/** @public */
type ComboboxProps<T extends {
    id: Key;
} = NormalizedOption> = ComboboxOptionsProps | ComboboxAsyncOptionsProps | ComboboxItemsProps<T> | ComboboxAsyncItemsProps<T> | ComboboxStaticProps | ComboboxServerOptionsProps | (T extends ComboboxServerItem ? ComboboxServerItemsProps<T> : never);
/** @public */
type ComboboxItemOwnProps = {
    children: ReactNode | ((values: ListBoxItemRenderProps) => ReactNode);
    textValue: string;
    /**
     * Show the built-in selection indicator and standard item content layout.
     */
    showSelectionIndicator?: boolean;
    className?: string;
};
/** @public */
type ComboboxItemProps<T extends object = object> = ComboboxItemOwnProps & Omit<ListBoxItemProps<T>, keyof ComboboxItemOwnProps>;
/** @public */
type ComboboxItemTextOwnProps = {
    title: string;
    description?: string;
    leadingIcon?: ReactNode;
    textValue?: string;
    className?: string;
};
/** @public */
type ComboboxItemTextProps<T extends object = object> = ComboboxItemTextOwnProps & Omit<ComboboxItemProps<T>, keyof ComboboxItemTextOwnProps | 'children' | 'showSelectionIndicator'>;
/** @public */
type ComboboxItemProfileOwnProps = {
    name: string;
    src?: string;
    textValue?: string;
    className?: string;
};
/** @public */
type ComboboxItemProfileProps<T extends object = object> = ComboboxItemProfileOwnProps & Omit<ComboboxItemProps<T>, keyof ComboboxItemProfileOwnProps | 'children' | 'showSelectionIndicator'>;

/** @public */
declare const Combobox: {
    (props: ComboboxOptionsProps & React.RefAttributes<HTMLDivElement>): React.ReactElement;
    (props: ComboboxAsyncOptionsProps & React.RefAttributes<HTMLDivElement>): React.ReactElement;
    <T extends {
        id: Key;
    }>(props: ComboboxItemsProps<T> & React.RefAttributes<HTMLDivElement>): React.ReactElement;
    <T extends {
        id: Key;
    }>(props: ComboboxAsyncItemsProps<T> & React.RefAttributes<HTMLDivElement>): React.ReactElement;
    (props: ComboboxStaticProps & React.RefAttributes<HTMLDivElement>): React.ReactElement;
    (props: ComboboxServerOptionsProps & React.RefAttributes<HTMLDivElement>): React.ReactElement;
    <T extends ComboboxServerItem>(props: ComboboxServerItemsProps<T> & React.RefAttributes<HTMLDivElement>): React.ReactElement;
    displayName?: string;
};

/**
 * A combobox item wrapper for custom content.
 *
 * @public
 */
declare function ComboboxItem<T extends object = object>(props: ComboboxItemProps<T>): react_jsx_runtime.JSX.Element;
/**
 * A combobox item that renders a title with an optional description and
 * leading icon.
 *
 * @public
 */
declare function ComboboxItemText<T extends object = object>(props: ComboboxItemTextProps<T>): react_jsx_runtime.JSX.Element;
/**
 * A combobox item that renders a profile name with an optional avatar.
 *
 * @public
 */
declare function ComboboxItemProfile<T extends object = object>(props: ComboboxItemProfileProps<T>): react_jsx_runtime.JSX.Element;

/** @public */
declare const ComboboxDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-Combobox";
        readonly popover: "bui-ComboboxPopover";
    };
    readonly propDefs: {
        readonly icon: {};
        readonly size: {
            readonly dataAttribute: true;
            readonly default: "small";
        };
        readonly options: {};
        readonly items: {};
        readonly children: {};
        readonly dependencies: {};
        readonly search: {};
        readonly loading: {};
        readonly placeholder: {};
        readonly label: {};
        readonly secondaryLabel: {};
        readonly description: {};
        readonly isRequired: {};
        readonly className: {};
    };
};
/** @public */
declare const ComboboxInputDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-ComboboxInput";
        readonly icon: "bui-ComboboxInputIcon";
        readonly input: "bui-ComboboxInputField";
        readonly chevron: "bui-ComboboxInputChevron";
    };
    readonly bg: "consumer";
    readonly propDefs: {
        readonly icon: {};
        readonly placeholder: {};
    };
};
/** @public */
declare const ComboboxListBoxDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-ComboboxList";
        readonly noResults: "bui-ComboboxNoResults";
        readonly loading: "bui-ComboboxLoading";
        readonly loadingRow: "bui-ComboboxLoadingRow";
    };
    readonly propDefs: {
        readonly options: {};
        readonly items: {};
        readonly children: {};
        readonly dependencies: {};
        readonly search: {};
        readonly loading: {};
        readonly isStale: {};
        readonly getItemTextValue: {};
    };
};
/** @public */
declare const ComboboxListBoxItemDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-ComboboxItem";
        readonly indicator: "bui-ComboboxItemIndicator";
        readonly label: "bui-ComboboxItemLabel";
    };
    readonly propDefs: {};
};
/** @public */
declare const ComboboxItemDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-ComboboxItem";
        readonly indicator: "bui-ComboboxItemIndicator";
        readonly content: "bui-ComboboxItemContent";
    };
    readonly propDefs: {
        readonly children: {};
        readonly textValue: {};
        readonly showSelectionIndicator: {};
        readonly className: {};
    };
};
/** @public */
declare const ComboboxItemTextDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-ComboboxItemText";
        readonly leadingIcon: "bui-ComboboxItemTextLeadingIcon";
        readonly text: "bui-ComboboxItemTextContent";
        readonly title: "bui-ComboboxItemTitle";
        readonly description: "bui-ComboboxItemDescription";
    };
    readonly propDefs: {
        readonly title: {};
        readonly description: {};
        readonly leadingIcon: {};
        readonly textValue: {};
        readonly className: {};
    };
};
/** @public */
declare const ComboboxItemProfileDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-ComboboxItemProfile";
        readonly avatar: "bui-ComboboxItemAvatar";
        readonly name: "bui-ComboboxItemTitle";
    };
    readonly propDefs: {
        readonly name: {};
        readonly src: {};
        readonly textValue: {};
        readonly className: {};
    };
};
/** @public */
declare const ComboboxSectionDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-ComboboxSection";
        readonly header: "bui-ComboboxSectionHeader";
    };
    readonly propDefs: {};
};

/** @public */
type RadioGroupOwnProps = {
    children?: ReactNode;
    className?: string;
    label?: FieldLabelProps['label'];
    secondaryLabel?: FieldLabelProps['secondaryLabel'];
    description?: FieldLabelProps['description'];
    isRequired?: RadioGroupProps$1['isRequired'];
};
/** @public */
interface RadioGroupProps extends RadioGroupOwnProps, Omit<RadioGroupProps$1, keyof RadioGroupOwnProps> {
}
/** @public */
type RadioOwnProps = {
    className?: string;
};
/** @public */
interface RadioProps extends RadioOwnProps, Omit<RadioProps$1, keyof RadioOwnProps> {
}

/**
 * A group of radio buttons for selecting a single option from a set, with an integrated label, description, and error display.
 *
 * @public
 */
declare const RadioGroup: react.ForwardRefExoticComponent<RadioGroupProps & react.RefAttributes<HTMLDivElement>>;
/**
 * A single radio button for use within a RadioGroup.
 *
 * @public
 */
declare const Radio: react.ForwardRefExoticComponent<RadioProps & react.RefAttributes<HTMLLabelElement>>;

/**
 * Component definition for RadioGroup
 * @public
 */
declare const RadioGroupDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-RadioGroup";
        readonly content: "bui-RadioGroupContent";
    };
    readonly propDefs: {
        readonly children: {};
        readonly className: {};
        readonly label: {};
        readonly secondaryLabel: {};
        readonly description: {};
        readonly isRequired: {};
    };
};
/**
 * Component definition for Radio
 * @public
 */
declare const RadioDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-Radio";
    };
    readonly propDefs: {
        readonly className: {};
    };
};

/** @public */
interface SliderOwnProps {
    className?: string;
    label?: FieldLabelProps['label'];
    secondaryLabel?: FieldLabelProps['secondaryLabel'];
    description?: FieldLabelProps['description'];
    isRequired?: boolean;
}
/** @public */
interface SliderProps<T extends number | number[]> extends Omit<SliderProps$1<T>, 'children' | 'className'>, SliderOwnProps {
}

/**
 * A draggable input for selecting a numeric value or range within a defined interval, with an integrated label and value output.
 *
 * @public
 */
declare const Slider: (<T extends number | number[]>(props: SliderProps<T> & {
    ref?: React.ForwardedRef<HTMLDivElement>;
}) => JSX.Element) & {
    displayName: string;
};

/**
 * Component definition for Slider
 * @public
 */
declare const SliderDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-Slider";
        readonly header: "bui-SliderHeader";
        readonly track: "bui-SliderTrack";
        readonly trackFill: "bui-SliderTrackFill";
        readonly thumb: "bui-SliderThumb";
        readonly output: "bui-SliderOutput";
    };
    readonly propDefs: {
        readonly className: {};
        readonly label: {};
        readonly secondaryLabel: {};
        readonly description: {};
        readonly isRequired: {};
    };
};

/** @public */
interface PageSizeOption {
    label: string;
    value: number;
}
/** @public */
type TablePaginationOwnProps = {
    pageSize: number;
    pageSizeOptions?: number[] | PageSizeOption[];
    offset?: number;
    totalCount?: number;
    hasNextPage: boolean;
    hasPreviousPage: boolean;
    onNextPage: () => void;
    onPreviousPage: () => void;
    onPageSizeChange?: (size: number) => void;
    showPageSizeOptions?: boolean;
    getLabel?: (params: {
        pageSize: number;
        offset?: number;
        totalCount?: number;
    }) => string;
    showPaginationLabel?: boolean;
};
/** @public */
interface TablePaginationProps extends TablePaginationOwnProps {
}

/**
 * Pagination controls for Table components with page navigation and size selection.
 *
 * @public
 */
declare function TablePagination(props: TablePaginationProps): react_jsx_runtime.JSX.Element;

/**
 * Component definition for TablePagination
 * @public
 */
declare const TablePaginationDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-TablePagination";
        readonly left: "bui-TablePaginationLeft";
        readonly right: "bui-TablePaginationRight";
        readonly select: "bui-TablePaginationSelect";
    };
    readonly propDefs: {
        readonly pageSize: {};
        readonly pageSizeOptions: {
            readonly default: PageSizeOption[];
        };
        readonly offset: {};
        readonly totalCount: {};
        readonly hasNextPage: {};
        readonly hasPreviousPage: {};
        readonly onNextPage: {};
        readonly onPreviousPage: {};
        readonly onPageSizeChange: {};
        readonly showPageSizeOptions: {
            readonly default: true;
        };
        readonly getLabel: {};
        readonly showPaginationLabel: {
            readonly default: true;
        };
    };
};

/**
 * @public
 */
type SortDescriptor = SortDescriptor$1;
/** @public */
interface SortState {
    descriptor: SortDescriptor | null;
    onSortChange: (descriptor: SortDescriptor) => void;
}
/** @public */
type TableRootOwnProps = {
    stale?: boolean;
    isPending?: boolean;
    /** @deprecated Use `isPending` instead. */
    loading?: boolean;
};
/** @public */
interface TableRootProps extends TableRootOwnProps, Omit<TableProps$1, keyof TableRootOwnProps> {
}
/** @public */
type TableHeaderOwnProps<T = object> = {
    columns?: TableHeaderProps$1<T>['columns'];
    children?: TableHeaderProps$1<T>['children'];
};
/** @public */
interface TableHeaderProps<T> extends TableHeaderOwnProps<T>, Omit<TableHeaderProps$1<T>, keyof TableHeaderOwnProps> {
}
/** @public */
type TableBodyOwnProps = {};
/** @public */
interface TableBodyProps<T extends object> extends TableBodyOwnProps, Omit<TableBodyProps$1<T>, keyof TableBodyOwnProps> {
}
/** @public */
type RowOwnProps<T = object> = {
    columns?: RowProps$1<T>['columns'];
    children?: RowProps$1<T>['children'];
    href?: string;
    noTrack?: boolean;
};
/** @public */
interface RowProps<T> extends RowOwnProps<T>, Omit<RowProps$1<T>, keyof RowOwnProps> {
}
/** @public */
type ColumnOwnProps = {
    children?: React.ReactNode;
    className?: string;
};
/** @public */
interface ColumnProps extends ColumnOwnProps, Omit<ColumnProps$1, keyof ColumnOwnProps> {
}
/**
 * Own props for the {@link Cell} component.
 *
 * @public
 */
type CellOwnProps = {
    className?: string;
};
/**
 * Props for the {@link Cell} component.
 *
 * `Cell` is a generic cell wrapper for custom cell content. When rendering
 * cells via {@link ColumnConfig.cell} or a custom {@link RowRenderFn}, the
 * returned element **must** be a cell component (`Cell`, `CellText`, or
 * `CellProfile`) at the top level. Returning bare text or other elements
 * without a cell wrapper will break the table layout.
 *
 * @public
 */
interface CellProps extends CellOwnProps, Omit<CellProps$1, keyof CellOwnProps> {
}
/**
 * Own props for the {@link CellText} component.
 *
 * @public
 */
type CellTextOwnProps = {
    title: string;
    description?: string;
    color?: TextColors;
    leadingIcon?: React.ReactNode | null;
    href?: string;
    className?: string;
};
/**
 * Props for the {@link CellText} component.
 *
 * `CellText` renders a table cell with a title and optional description. It
 * is one of the cell components (`Cell`, `CellText`, `CellProfile`) that
 * **must** be used as the top-level element returned from
 * {@link ColumnConfig.cell} or a custom {@link RowRenderFn}.
 *
 * @public
 */
interface CellTextProps extends CellTextOwnProps, Omit<CellProps$1, keyof CellTextOwnProps> {
}
/**
 * Own props for the {@link CellProfile} component.
 *
 * @public
 */
type CellProfileOwnProps = {
    src?: string;
    name?: string;
    href?: string;
    description?: string;
    color?: TextColors;
    className?: string;
};
/**
 * Props for the {@link CellProfile} component.
 *
 * `CellProfile` renders a table cell with an avatar, name, and optional
 * description. It is one of the cell components (`Cell`, `CellText`,
 * `CellProfile`) that **must** be used as the top-level element returned
 * from {@link ColumnConfig.cell} or a custom {@link RowRenderFn}.
 *
 * @public
 */
interface CellProfileProps extends CellProfileOwnProps, Omit<CellProps$1, keyof CellProfileOwnProps> {
}
/** @public */
interface TableItem {
    id: string | number;
}
/** @public */
interface NoPagination {
    type: 'none';
}
/** @public */
interface PagePagination extends TablePaginationProps {
    type: 'page';
}
/** @public */
type TablePaginationType = NoPagination | PagePagination;
/**
 * Configuration for a single table column.
 *
 * @public
 */
interface ColumnConfig<T extends TableItem> {
    id: string;
    label: string;
    /**
     * Renders the cell content for this column.
     *
     * **Important:** The returned element **must** be a cell component at the
     * top level — either `Cell`, `CellText`, or `CellProfile`. Returning bare
     * text, fragments, or other elements without a cell wrapper will break the
     * table layout.
     *
     * @example
     * ```tsx
     * cell: item => <CellText title={item.name} />
     * ```
     */
    cell: (item: T) => ReactElement;
    header?: () => ReactElement;
    isSortable?: boolean;
    isHidden?: boolean;
    width?: ColumnSize | null;
    defaultWidth?: ColumnSize | null;
    minWidth?: ColumnStaticSize | null;
    maxWidth?: ColumnStaticSize | null;
    isRowHeader?: boolean;
}
/** @public */
interface RowConfig<T extends TableItem> {
    getHref?: (item: T) => string | undefined;
    onClick?: (item: T) => void;
    getIsDisabled?: (item: T) => boolean;
}
/**
 * Custom render function for table rows.
 *
 * When using a custom row render function, each cell rendered inside the row
 * **must** use a cell component (`Cell`, `CellText`, or `CellProfile`) as
 * the top-level element. Returning bare text or other elements without a
 * cell wrapper will break the table layout.
 *
 * @public
 */
type RowRenderFn<T extends TableItem> = (params: {
    item: T;
    index: number;
}) => ReactNode;
/** @public */
interface TableSelection {
    mode?: TableProps$1['selectionMode'];
    behavior?: TableProps$1['selectionBehavior'];
    selected?: TableProps$1['selectedKeys'];
    onSelectionChange?: TableProps$1['onSelectionChange'];
}
/** @public */
type VirtualizedProp = boolean | {
    rowHeight: number;
} | {
    estimatedRowHeight: number;
};
/** @public */
interface TableProps<T extends TableItem> {
    columnConfig: readonly ColumnConfig<T>[];
    data: T[] | undefined;
    isPending?: boolean;
    /** @deprecated Use `isPending` instead. */
    loading?: boolean;
    isStale?: boolean;
    error?: Error;
    pagination: TablePaginationType;
    sort?: SortState;
    rowConfig?: RowConfig<T> | RowRenderFn<T>;
    selection?: TableSelection;
    emptyState?: ReactNode;
    className?: string;
    style?: React.CSSProperties;
    virtualized?: VirtualizedProp;
}

/**
 * A full-featured data table with built-in pagination, sorting, row selection, loading and error states, and optional virtualization.
 * Pair with `useTable` to manage data fetching and state, or pass `data`, `columnConfig`, and `pagination` directly for manual control.
 *
 * @public
 */
declare function Table<T extends TableItem>({ columnConfig, data, isPending, loading, isStale, error, pagination, sort, rowConfig, selection, emptyState, className, style, virtualized, }: TableProps<T>): react_jsx_runtime.JSX.Element;

/**
 * The low-level table root element for building custom table layouts from atomic components.
 * For most use cases, prefer the `Table` convenience wrapper.
 *
 * @public
 */
declare const TableRoot: (props: TableRootProps) => react_jsx_runtime.JSX.Element;

/**
 * The header row of a table, rendering column labels and an optional select-all checkbox for toggle selection mode.
 *
 * @public
 */
declare const TableHeader: <T extends object>(props: TableHeaderProps<T>) => react_jsx_runtime.JSX.Element;

/**
 * The body section of a table that renders data rows from the provided items collection.
 *
 * @public
 */
declare const TableBody: <T extends object>(props: TableBodyProps<T>) => react_jsx_runtime.JSX.Element;

/**
 * A table column header cell with an optional sort toggle and support for resizable widths.
 *
 * @public
 */
declare const Column: (props: ColumnProps) => react_jsx_runtime.JSX.Element;

/**
 * A table row that can optionally act as a navigation link or trigger an action when clicked, with analytics tracking.
 *
 * @public
 */
declare function Row<T extends object>(props: RowProps<T>): react_jsx_runtime.JSX.Element;

/**
 * A low-level table cell primitive for building custom cell content.
 * For standard use cases, prefer `CellText` or `CellProfile`.
 *
 * @public
 */
declare const Cell: {
    (props: CellProps): react_jsx_runtime.JSX.Element;
    displayName: string;
};

/**
 * A table cell that renders a primary text title with an optional secondary description, leading icon, and link.
 *
 * @public
 */
declare const CellText: {
    (props: CellTextProps): react_jsx_runtime.JSX.Element;
    displayName: string;
};

/**
 * A table cell that renders an avatar image alongside a name, with an optional description and link.
 *
 * @public
 */
declare const CellProfile: (props: CellProfileProps) => react_jsx_runtime.JSX.Element;

/**
 * A table body that renders animated skeleton rows as a loading placeholder.
 *
 * @remarks
 * Accepts any column array whose items have an `id` property, making it
 * compatible with both `ColumnConfig` and custom column types.
 *
 * @public
 */
declare function TableBodySkeleton<T extends {
    id: string;
}>({ columns, }: {
    columns: readonly T[];
}): react_jsx_runtime.JSX.Element;

/** @public */
interface FilterState<TFilter> {
    value: TFilter | undefined;
    onChange: (value: TFilter) => void;
}
/** @public */
interface SearchState {
    value: string;
    onChange: (value: string) => void;
}
/** @public */
interface QueryOptions<TFilter> {
    initialSort?: SortDescriptor;
    sort?: SortDescriptor | null;
    onSortChange?: (sort: SortDescriptor) => void;
    initialFilter?: TFilter;
    filter?: TFilter;
    onFilterChange?: (filter: TFilter) => void;
    initialSearch?: string;
    search?: string;
    onSearchChange?: (search: string) => void;
}
/** @public */
interface PaginationOptions extends Partial<Pick<TablePaginationProps, 'pageSize' | 'pageSizeOptions' | 'onPageSizeChange' | 'onNextPage' | 'onPreviousPage' | 'showPageSizeOptions' | 'getLabel' | 'showPaginationLabel'>> {
    initialOffset?: number;
}
/** @public */
interface CompletePaginationOptions extends PaginationOptions {
    type?: 'page' | 'none';
}
/** @public */
interface OffsetParams<TFilter> {
    offset: number;
    pageSize: number;
    sort: SortDescriptor | null;
    filter: TFilter | undefined;
    search: string;
    signal: AbortSignal;
}
/** @public */
interface CursorParams<TFilter> {
    cursor: string | undefined;
    pageSize: number;
    sort: SortDescriptor | null;
    filter: TFilter | undefined;
    search: string;
    signal: AbortSignal;
}
/** @public */
interface OffsetResponse<T> {
    data: T[];
    totalCount: number;
}
/** @public */
interface CursorResponse<T> {
    data: T[];
    nextCursor?: string;
    prevCursor?: string;
    totalCount?: number;
}
/** @public */
type UseTableCompleteOptions<T extends TableItem, TFilter = unknown> = QueryOptions<TFilter> & {
    mode: 'complete';
    paginationOptions?: CompletePaginationOptions;
    sortFn?: (data: T[], sort: SortDescriptor) => T[];
    filterFn?: (data: T[], filter: TFilter) => T[];
    searchFn?: (data: T[], search: string) => T[];
    /**
     * Trailing-edge debounce delay (ms) applied to the search value before it
     * reaches `searchFn`. Defaults to `0` — no debounce, no extra render. The
     * controlled `search` / `onSearchChange` surface is unaffected.
     */
    searchDebounceMs?: number;
    /**
     * Trailing-edge debounce delay (ms) applied to the filter value before it
     * reaches `filterFn`. Defaults to `0` — no debounce, no extra render. The
     * controlled `filter` / `onFilterChange` surface is unaffected.
     */
    filterDebounceMs?: number;
} & ({
    data: T[] | undefined;
    getData?: never;
} | {
    data?: never;
    getData: () => T[] | Promise<T[]>;
});
/** @public */
interface UseTableOffsetOptions<T extends TableItem, TFilter = unknown> extends QueryOptions<TFilter> {
    mode: 'offset';
    getData: (params: OffsetParams<TFilter>) => Promise<OffsetResponse<T>>;
    paginationOptions?: PaginationOptions;
}
/** @public */
interface UseTableCursorOptions<T extends TableItem, TFilter = unknown> extends QueryOptions<TFilter> {
    mode: 'cursor';
    getData: (params: CursorParams<TFilter>) => Promise<CursorResponse<T>>;
    paginationOptions?: Omit<PaginationOptions, 'initialOffset'>;
}
/** @public */
type UseTableOptions<T extends TableItem, TFilter = unknown> = UseTableCompleteOptions<T, TFilter> | UseTableOffsetOptions<T, TFilter> | UseTableCursorOptions<T, TFilter>;
/** @public */
interface UseTableResult<T extends TableItem, TFilter = unknown> {
    tableProps: Omit<TableProps<T>, 'columnConfig' | 'rowConfig' | 'selection' | 'emptyState'>;
    reload: () => void;
    filter: FilterState<TFilter>;
    search: SearchState;
}

/**
 * A hook that manages table data fetching, pagination, sorting, search, and filtering.
 * Supports three modes: `complete` for client-side data, `offset` for server-side offset pagination, and `cursor` for server-side cursor pagination.
 *
 * @public
 */
declare function useTable<T extends TableItem, TFilter = unknown>(options: UseTableCompleteOptions<T, TFilter>): UseTableResult<T, TFilter>;
/** @public */
declare function useTable<T extends TableItem, TFilter = unknown>(options: UseTableOffsetOptions<T, TFilter>): UseTableResult<T, TFilter>;
/** @public */
declare function useTable<T extends TableItem, TFilter = unknown>(options: UseTableCursorOptions<T, TFilter>): UseTableResult<T, TFilter>;

/**
 * Component definition for Table
 * @public
 */
declare const TableDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-Table";
    };
    readonly propDefs: {
        readonly stale: {
            readonly dataAttribute: true;
        };
        readonly isPending: {
            readonly dataAttribute: true;
        };
        readonly loading: {
            readonly dataAttribute: true;
        };
    };
};

/**
 * Own props for the TagGroup component.
 *
 * @public
 */
type TagGroupOwnProps<T = object> = {
    items?: TagListProps<T>['items'];
    children?: TagListProps<T>['children'];
    renderEmptyState?: TagListProps<T>['renderEmptyState'];
    className?: string;
};
/**
 * Props for the TagGroup component.
 *
 * @public
 */
interface TagGroupProps<T> extends TagGroupOwnProps<T>, Omit<TagGroupProps$1, 'children' | keyof TagGroupOwnProps> {
}
/**
 * Own props for the Tag component.
 *
 * @public
 */
type TagOwnProps = {
    /**
     * The icon to display in the chip.
     */
    icon?: React.ReactNode;
    /**
     * The size of the chip.
     */
    size?: 'small' | 'medium';
    href?: TagProps$1['href'];
    children?: TagProps$1['children'];
    className?: string;
    noTrack?: boolean;
};
/**
 * Props for the Tag component.
 *
 * @public
 */
interface TagProps extends TagOwnProps, Omit<TagProps$1, keyof TagOwnProps> {
}

/**
 * A component that renders a list of tags.
 *
 * @public
 */
declare const TagGroup: <T extends object>(props: TagGroupProps<T>) => react_jsx_runtime.JSX.Element;
/**
 * A component that renders a tag.
 *
 * @public
 */
declare const Tag: react.ForwardRefExoticComponent<TagProps & react.RefAttributes<HTMLDivElement>>;

/**
 * Component definition for TagGroup
 * @public
 */
declare const TagGroupDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-TagGroup";
        readonly list: "bui-TagList";
    };
    readonly propDefs: {
        readonly items: {};
        readonly children: {};
        readonly renderEmptyState: {};
        readonly className: {};
    };
};

/** @public */
type TextOwnProps = {
    as?: 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'p' | 'span' | 'label' | 'div' | 'strong' | 'em' | 'small' | 'legend';
    variant?: TextVariants | Partial<Record<Breakpoint, TextVariants>>;
    weight?: TextWeights | Partial<Record<Breakpoint, TextWeights>>;
    color?: TextColors | TextColorStatus | Partial<Record<Breakpoint, TextColors | TextColorStatus>>;
    truncate?: boolean;
    className?: string;
};
/** @public */
type TextProps<T extends ElementType = 'span'> = TextOwnProps & Omit<ComponentPropsWithRef<T>, keyof TextOwnProps>;

/**
 * A typographic primitive that renders text with design system variants, weights, and colors, and can render as any HTML element.
 *
 * @public
 */
declare const Text: {
    <T extends ElementType = "p">(props: TextProps<T> & {
        ref?: React.ComponentPropsWithRef<T>["ref"];
    }): React.ReactElement<TextProps<T>, T>;
    displayName: string;
};

/**
 * Component definition for Text
 * @public
 */
declare const TextDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-Text";
    };
    readonly propDefs: {
        readonly as: {
            readonly default: "span";
        };
        readonly variant: {
            readonly dataAttribute: true;
            readonly default: "body-medium";
        };
        readonly weight: {
            readonly dataAttribute: true;
            readonly default: "regular";
        };
        readonly color: {
            readonly dataAttribute: true;
            readonly default: "primary";
        };
        readonly truncate: {
            readonly dataAttribute: true;
        };
        readonly className: {};
    };
};

/** @public */
type TextFieldOwnProps = {
    /**
     * The size of the text field
     * @defaultValue 'medium'
     */
    size?: 'small' | 'medium' | Partial<Record<Breakpoint, 'small' | 'medium'>>;
    className?: string;
    /**
     * An icon to render before the input
     */
    icon?: ReactNode;
    /**
     * Text to display in the input when it has no value
     */
    placeholder?: string;
    label?: FieldLabelProps['label'];
    description?: FieldLabelProps['description'];
    secondaryLabel?: FieldLabelProps['secondaryLabel'];
};
/** @public */
interface TextFieldProps extends Omit<TextFieldProps$1, 'className' | 'description'>, TextFieldOwnProps {
    /**
     * The HTML input type for the text field
     *
     * @remarks
     * Use `SearchField` for
     * search inputs and `PasswordField` for password inputs.
     */
    type?: 'text' | 'email' | 'tel' | 'url';
}

/**
 * A single-line text input with an integrated label, optional icon, and inline error display.
 *
 * @public
 */
declare const TextField: react.ForwardRefExoticComponent<TextFieldProps & react.RefAttributes<HTMLDivElement>>;

/**
 * Component definition for TextField
 * @public
 */
declare const TextFieldDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-TextField";
        readonly inputWrapper: "bui-InputWrapper";
        readonly input: "bui-Input";
        readonly inputIcon: "bui-InputIcon";
        readonly inputAction: "bui-InputAction";
    };
    readonly bg: "consumer";
    readonly propDefs: {
        readonly size: {
            readonly dataAttribute: true;
            readonly default: "small";
        };
        readonly className: {};
        readonly icon: {};
        readonly placeholder: {};
        readonly label: {};
        readonly description: {};
        readonly secondaryLabel: {};
    };
};

/** @public */
type NumberFieldOwnProps = {
    /**
     * The size of the number field
     * @defaultValue 'small'
     */
    size?: 'small' | 'medium' | Partial<Record<Breakpoint, 'small' | 'medium'>>;
    className?: string;
    /**
     * An icon to render before the input
     */
    icon?: ReactNode;
    /**
     * Text to display in the input when it has no value
     */
    placeholder?: string;
    label?: FieldLabelProps['label'];
    description?: FieldLabelProps['description'];
    secondaryLabel?: FieldLabelProps['secondaryLabel'];
};
/** @public */
interface NumberFieldProps extends Omit<NumberFieldProps$1, 'className' | 'description'>, NumberFieldOwnProps {
}

/**
 * A numeric input with an integrated label, optional icon, and inline error display.
 *
 * @public
 */
declare const NumberField: react.ForwardRefExoticComponent<NumberFieldProps & react.RefAttributes<HTMLDivElement>>;

/**
 * Component definition for NumberField
 * @public
 */
declare const NumberFieldDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-NumberField";
        readonly inputWrapper: "bui-InputWrapper";
        readonly input: "bui-Input";
        readonly inputIcon: "bui-InputIcon";
        readonly stepperButtons: "bui-StepperButtons";
        readonly stepperButton: "bui-StepperButton";
    };
    readonly bg: "consumer";
    readonly propDefs: {
        readonly size: {
            readonly dataAttribute: true;
            readonly default: "small";
        };
        readonly className: {};
        readonly icon: {};
        readonly placeholder: {};
        readonly label: {};
        readonly description: {};
        readonly secondaryLabel: {};
    };
};

/** @public */
type PasswordFieldOwnProps = {
    /**
     * The size of the password field
     * @defaultValue 'medium'
     */
    size?: 'small' | 'medium' | Partial<Record<Breakpoint, 'small' | 'medium'>>;
    className?: string;
    /**
     * An icon to render before the input
     */
    icon?: ReactNode;
    /**
     * Text to display in the input when it has no value
     */
    placeholder?: string;
    label?: FieldLabelProps['label'];
    description?: FieldLabelProps['description'];
    secondaryLabel?: FieldLabelProps['secondaryLabel'];
};
/** @public */
interface PasswordFieldProps extends Omit<TextFieldProps$1, 'className' | 'description'>, PasswordFieldOwnProps {
}

/**
 * A text input for password entry with a toggleable visibility button, integrated label, and inline error display.
 *
 * @public
 */
declare const PasswordField: react.ForwardRefExoticComponent<PasswordFieldProps & react.RefAttributes<HTMLDivElement>>;

/**
 * Component definition for PasswordField
 * @public
 */
declare const PasswordFieldDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-PasswordField";
        readonly inputWrapper: "bui-PasswordFieldInputWrapper";
        readonly input: "bui-PasswordFieldInput";
        readonly inputIcon: "bui-PasswordFieldIcon";
        readonly inputVisibility: "bui-PasswordFieldVisibility";
    };
    readonly bg: "consumer";
    readonly propDefs: {
        readonly size: {
            readonly dataAttribute: true;
            readonly default: "small";
        };
        readonly className: {};
        readonly icon: {};
        readonly placeholder: {};
        readonly label: {};
        readonly description: {};
        readonly secondaryLabel: {};
    };
};

/** @public */
type TooltipOwnProps = {
    children: React.ReactNode;
    className?: string;
};
/** @public */
interface TooltipProps extends Omit<TooltipProps$1, 'children' | 'className'>, TooltipOwnProps {
}

/**
 * A wrapper that connects a trigger element to a Tooltip, controlling its show and hide behavior with a configurable delay.
 *
 * @public
 */
declare const TooltipTrigger: (props: TooltipTriggerComponentProps) => react_jsx_runtime.JSX.Element;
/**
 * A floating label that provides contextual information about an element when it receives hover or focus.
 *
 * @public
 */
declare const Tooltip: react.ForwardRefExoticComponent<TooltipProps & react.RefAttributes<HTMLDivElement>>;

/**
 * Component definition for Tooltip
 * @public
 */
declare const TooltipDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly tooltip: "bui-Tooltip";
        readonly content: "bui-TooltipContent";
        readonly arrow: "bui-TooltipArrow";
    };
    readonly propDefs: {
        readonly children: {};
        readonly className: {};
    };
};

/** @public */
interface MenuTriggerProps extends MenuTriggerProps$1 {
}
/** @public */
interface SubmenuTriggerProps extends SubmenuTriggerProps$1 {
}
/**
 * Common own props shared by all Menu popover variants.
 *
 * @public
 */
type MenuPopoverOwnProps = {
    placement?: PopoverProps$1['placement'];
    virtualized?: boolean;
    maxWidth?: string;
    maxHeight?: string;
    style?: React.CSSProperties;
    className?: string;
};
/** @public */
type MenuOwnProps = MenuPopoverOwnProps;
/** @public */
interface MenuProps<T> extends MenuOwnProps, Omit<MenuProps$1<T>, keyof MenuOwnProps> {
}
/** @public */
type MenuListBoxOwnProps = MenuPopoverOwnProps & {
    selectionMode?: ListBoxProps<object>['selectionMode'];
};
/** @public */
interface MenuListBoxProps<T> extends MenuListBoxOwnProps, Omit<ListBoxProps<T>, keyof MenuListBoxOwnProps> {
}
/** @public */
type MenuAutocompleteOwnProps = MenuPopoverOwnProps & {
    placeholder?: string;
};
/** @public */
interface MenuAutocompleteProps<T> extends MenuAutocompleteOwnProps, Omit<MenuProps$1<T>, keyof MenuAutocompleteOwnProps> {
}
/** @public */
type MenuAutocompleteListBoxOwnProps = MenuPopoverOwnProps & {
    placeholder?: string;
    selectionMode?: ListBoxProps<object>['selectionMode'];
};
/** @public */
interface MenuAutocompleteListBoxProps<T> extends MenuAutocompleteListBoxOwnProps, Omit<ListBoxProps<T>, keyof MenuAutocompleteListBoxOwnProps> {
}
/** @public */
type MenuItemOwnProps = {
    iconStart?: React.ReactNode;
    children: React.ReactNode;
    color?: 'primary' | 'danger';
    href?: MenuItemProps$1['href'];
    noTrack?: boolean;
    className?: string;
};
/** @public */
interface MenuItemProps extends MenuItemOwnProps, Omit<MenuItemProps$1, keyof MenuItemOwnProps> {
}
/** @public */
type MenuListBoxItemOwnProps = {
    children: React.ReactNode;
    className?: string;
};
/** @public */
interface MenuListBoxItemProps extends MenuListBoxItemOwnProps, Omit<ListBoxItemProps, keyof MenuListBoxItemOwnProps> {
}
/** @public */
type MenuSectionOwnProps = {
    title: string;
    children: React.ReactNode;
    className?: string;
};
/** @public */
interface MenuSectionProps<T> extends MenuSectionOwnProps, Omit<MenuSectionProps$1<T>, keyof MenuSectionOwnProps> {
}
/** @public */
type MenuSeparatorOwnProps = {
    className?: string;
};
/** @public */
interface MenuSeparatorProps extends MenuSeparatorOwnProps, Omit<SeparatorProps, keyof MenuSeparatorOwnProps> {
}

/**
 * A wrapper that connects a trigger element to a dropdown menu, controlling its open and close state.
 *
 * @public
 */
declare const MenuTrigger: (props: MenuTriggerProps) => react_jsx_runtime.JSX.Element;
/** @public */
declare const SubmenuTrigger: (props: SubmenuTriggerProps) => react_jsx_runtime.JSX.Element;
/** @public */
declare const Menu: (props: MenuProps<object>) => react_jsx_runtime.JSX.Element;
/** @public */
declare const MenuListBox: (props: MenuListBoxProps<object>) => react_jsx_runtime.JSX.Element;
/** @public */
declare const MenuAutocomplete: (props: MenuAutocompleteProps<object>) => react_jsx_runtime.JSX.Element;
/** @public */
declare const MenuAutocompleteListbox: (props: MenuAutocompleteListBoxProps<object>) => react_jsx_runtime.JSX.Element;
/** @public */
declare const MenuItem: (props: MenuItemProps) => react_jsx_runtime.JSX.Element;
/** @public */
declare const MenuListBoxItem: (props: MenuListBoxItemProps) => react_jsx_runtime.JSX.Element;
/** @public */
declare const MenuSection: (props: MenuSectionProps<object>) => react_jsx_runtime.JSX.Element;
/** @public */
declare const MenuSeparator: (props: MenuSeparatorProps) => react_jsx_runtime.JSX.Element;

/**
 * Component definition for Menu
 * @public
 */
declare const MenuDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-MenuPopover";
        readonly inner: "bui-MenuInner";
        readonly content: "bui-MenuContent";
    };
    readonly propDefs: {
        readonly placement: {
            readonly default: "bottom start";
        };
        readonly virtualized: {
            readonly default: false;
        };
        readonly maxWidth: {};
        readonly maxHeight: {};
        readonly style: {};
        readonly className: {};
    };
};

/** @public */
type PopoverOwnProps = {
    /**
     * The content to display inside the popover.
     * Content is automatically wrapped with padding and scroll behavior.
     */
    children: React.ReactNode;
    /**
     * Whether to hide the arrow pointing to the trigger element.
     * Arrow is also automatically hidden for MenuTrigger and SubmenuTrigger contexts.
     *
     * @defaultValue false
     */
    hideArrow?: boolean;
    className?: string;
};
/**
 * Properties for {@link Popover}
 *
 * @public
 */
interface PopoverProps extends Omit<PopoverProps$1, 'children' | 'className'>, PopoverOwnProps {
}

/**
 * A popover component built on React Aria Components that displays floating
 * content anchored to a trigger element.
 *
 * @remarks
 * The Popover component supports multiple placements (top, right, bottom, left),
 * automatic viewport-constrained scrolling, and conditional arrow rendering. It
 * automatically handles positioning, collision detection, and ARIA attributes for
 * accessibility. Content is automatically padded and scrollable when it exceeds
 * available space.
 *
 * @example
 * Basic usage with DialogTrigger:
 * ```tsx
 * <DialogTrigger>
 *   <Button>Open Popover</Button>
 *   <Popover>
 *     <Text>Popover content</Text>
 *   </Popover>
 * </DialogTrigger>
 * ```
 *
 * @example
 * With custom placement and no arrow:
 * ```tsx
 * <DialogTrigger>
 *   <Button>Open</Button>
 *   <Popover placement="right" hideArrow>
 *     <Text>Content without arrow</Text>
 *   </Popover>
 * </DialogTrigger>
 * ```
 *
 * @public
 */
declare const Popover: react.ForwardRefExoticComponent<PopoverProps & react.RefAttributes<HTMLDivElement>>;

/**
 * Component definition for Popover
 * @public
 */
declare const PopoverDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-Popover";
        readonly arrow: "bui-PopoverArrow";
        readonly content: "bui-PopoverContent";
    };
    readonly propDefs: {
        readonly children: {};
        readonly hideArrow: {};
        readonly className: {};
    };
};

/** @public */
type SearchAutocompleteOwnProps = {
    /**
     * The current value of the search input (controlled).
     */
    inputValue?: string;
    /**
     * Handler called when the search input value changes.
     */
    onInputChange?: (value: string) => void;
    /**
     * The size of the search input.
     * @defaultValue 'small'
     */
    size?: 'small' | 'medium' | Partial<Record<Breakpoint, 'small' | 'medium'>>;
    /**
     * Accessible label for the search input.
     */
    'aria-label'?: string;
    /**
     * ID of the element that labels the search input.
     */
    'aria-labelledby'?: string;
    /**
     * The placeholder text for the search input.
     */
    placeholder?: string;
    /**
     * Width of the results popover. Accepts any CSS width value.
     * When not set, the popover matches the input width.
     */
    popoverWidth?: string;
    /**
     * Placement of the results popover relative to the input.
     * @defaultValue 'bottom start'
     */
    popoverPlacement?: PopoverProps$1['placement'];
    /**
     * The result items to render inside the autocomplete.
     */
    children?: ReactNode;
    /**
     * Whether results are currently loading.
     * When true, displays a loading indicator and announces the loading state to screen readers.
     */
    isLoading?: boolean;
    /**
     * Whether the results popover is open by default.
     */
    defaultOpen?: boolean;
    className?: string;
    style?: React.CSSProperties;
};
/** @public */
interface SearchAutocompleteProps extends SearchAutocompleteOwnProps {
}
/** @public */
type SearchAutocompleteItemOwnProps = {
    children: ReactNode;
    className?: string;
};
/** @public */
interface SearchAutocompleteItemProps extends SearchAutocompleteItemOwnProps, Omit<ListBoxItemProps, keyof SearchAutocompleteItemOwnProps> {
}

/**
 * A search input that shows a dropdown list of suggestions as the user types, with loading and empty states.
 *
 * @public
 */
declare function SearchAutocomplete(props: SearchAutocompleteProps): react_jsx_runtime.JSX.Element;
/**
 * An individual option item within a SearchAutocomplete dropdown.
 *
 * @public
 */
declare function SearchAutocompleteItem(props: SearchAutocompleteItemProps): react_jsx_runtime.JSX.Element;

/**
 * Component definition for SearchAutocomplete.
 * @public
 */
declare const SearchAutocompleteDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly bg: "consumer";
    readonly classNames: {
        readonly root: "bui-SearchAutocomplete";
        readonly searchField: "bui-SearchAutocompleteSearchField";
        readonly searchFieldInput: "bui-SearchAutocompleteInput";
        readonly searchFieldClear: "bui-SearchAutocompleteClear";
        readonly popover: "bui-SearchAutocompletePopover";
        readonly inner: "bui-SearchAutocompleteInner";
        readonly listBox: "bui-SearchAutocompleteListBox";
        readonly loadingState: "bui-SearchAutocompleteLoadingState";
        readonly emptyState: "bui-SearchAutocompleteEmptyState";
    };
    readonly propDefs: {
        readonly 'aria-label': {};
        readonly 'aria-labelledby': {};
        readonly size: {
            readonly dataAttribute: true;
            readonly default: "small";
        };
        readonly placeholder: {
            readonly default: "Search";
        };
        readonly inputValue: {};
        readonly onInputChange: {};
        readonly popoverWidth: {};
        readonly popoverPlacement: {};
        readonly children: {};
        readonly isLoading: {};
        readonly defaultOpen: {};
        readonly className: {};
        readonly style: {};
    };
};

/** @public */
type SearchFieldOwnProps = {
    /**
     * An icon to render before the input
     */
    icon?: ReactNode | false;
    /**
     * The size of the text field
     * @defaultValue 'medium'
     */
    size?: 'small' | 'medium' | Partial<Record<Breakpoint, 'small' | 'medium'>>;
    /**
     * The placeholder text for the input
     */
    placeholder?: string;
    /**
     * Controls whether the SearchField starts in a collapsed state.
     */
    startCollapsed?: boolean;
    className?: string;
    label?: FieldLabelProps['label'];
    description?: FieldLabelProps['description'];
    secondaryLabel?: FieldLabelProps['secondaryLabel'];
};
/** @public */
interface SearchFieldProps extends Omit<SearchFieldProps$1, 'className' | 'description'>, SearchFieldOwnProps {
}

/**
 * A text input optimized for search queries, with a built-in clear button, optional icon, and support for a collapsible mode.
 *
 * @public
 */
declare const SearchField: react.ForwardRefExoticComponent<SearchFieldProps & react.RefAttributes<HTMLDivElement>>;

/**
 * Component definition for SearchField
 * @public
 */
declare const SearchFieldDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-SearchField";
        readonly clear: "bui-SearchFieldClear";
        readonly inputWrapper: "bui-SearchFieldInputWrapper";
        readonly input: "bui-SearchFieldInput";
        readonly inputIcon: "bui-SearchFieldInputIcon";
    };
    readonly bg: "consumer";
    readonly propDefs: {
        readonly startCollapsed: {
            readonly dataAttribute: true;
            readonly default: false;
        };
        readonly size: {
            readonly dataAttribute: true;
            readonly default: "small";
        };
        readonly className: {};
        readonly icon: {};
        readonly placeholder: {
            readonly default: "Search";
        };
        readonly label: {};
        readonly description: {};
        readonly secondaryLabel: {};
    };
};

/** @public */
type LinkOwnProps = {
    noTrack?: boolean;
    variant?: TextVariants | Partial<Record<Breakpoint, TextVariants>>;
    weight?: TextWeights | Partial<Record<Breakpoint, TextWeights>>;
    color?: TextColors | TextColorStatus | Partial<Record<Breakpoint, TextColors | TextColorStatus>>;
    truncate?: boolean;
    standalone?: boolean;
    title?: string;
    children?: ReactNode;
    className?: string;
};
/** @public */
interface LinkProps extends Omit<LinkProps$1, 'children' | 'className'>, LinkOwnProps {
}

/**
 * A styled anchor element that supports analytics event tracking on click.
 *
 * @public
 */
declare const Link: react.ForwardRefExoticComponent<LinkProps & react.RefAttributes<HTMLAnchorElement>>;

/**
 * Component definition for Link
 * @public
 */
declare const LinkDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-Link";
    };
    readonly analytics: true;
    readonly propDefs: {
        readonly noTrack: {};
        readonly variant: {
            readonly dataAttribute: true;
            readonly default: "body-medium";
        };
        readonly weight: {
            readonly dataAttribute: true;
            readonly default: "regular";
        };
        readonly color: {
            readonly dataAttribute: true;
            readonly default: "primary";
        };
        readonly truncate: {
            readonly dataAttribute: true;
        };
        readonly standalone: {
            readonly dataAttribute: true;
        };
        readonly title: {};
        readonly children: {};
        readonly className: {};
    };
};

/**
 * Own props for the List component.
 *
 * @public
 */
type ListOwnProps<T = object> = {
    items?: GridListProps<T>['items'];
    children?: GridListProps<T>['children'];
    renderEmptyState?: GridListProps<T>['renderEmptyState'];
    className?: string;
};
/**
 * Props for the List component.
 *
 * @public
 */
interface ListProps<T> extends ListOwnProps<T>, Omit<GridListProps<T>, keyof ListOwnProps<T>> {
}
/**
 * Own props for the ListRow component.
 *
 * @public
 */
type ListRowOwnProps = {
    /**
     * The main label content of the row.
     */
    children?: React.ReactNode;
    /**
     * Optional secondary description text.
     */
    description?: string;
    /**
     * Optional icon displayed before the label, rendered in a 32×32px box.
     */
    icon?: React.ReactElement;
    /**
     * Optional menu items rendered inside an automatically managed dropdown menu.
     * Pass `MenuItem` nodes here and the component will render the trigger button
     * and menu wrapper for you.
     */
    menuItems?: React.ReactNode;
    /**
     * Optional actions rendered in a flex row on the right side of the row,
     * e.g. a set of tags. For a dropdown menu, prefer `menuItems`.
     */
    customActions?: React.ReactNode;
    className?: string;
};
/**
 * Props for the ListRow component.
 *
 * @public
 */
interface ListRowProps extends ListRowOwnProps, Omit<GridListItemProps, keyof ListRowOwnProps> {
}

/**
 * A list displays a list of interactive rows with support for keyboard
 * navigation, single or multiple selection, and row actions.
 *
 * @public
 */
declare const List: <T extends object>(props: ListProps<T>) => react_jsx_runtime.JSX.Element;
/**
 * A row within a List.
 *
 * @public
 */
declare const ListRow: (props: ListRowProps) => react_jsx_runtime.JSX.Element;

/**
 * Component definition for List
 * @public
 */
declare const ListDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-List";
    };
    readonly propDefs: {
        readonly items: {};
        readonly children: {};
        readonly renderEmptyState: {};
        readonly className: {};
    };
};
/**
 * Component definition for ListRow
 * @public
 */
declare const ListRowDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly bg: "consumer";
    readonly classNames: {
        readonly root: "bui-ListRow";
        readonly check: "bui-ListRowCheck";
        readonly icon: "bui-ListRowIcon";
        readonly label: "bui-ListRowLabel";
        readonly description: "bui-ListRowDescription";
        readonly actions: "bui-ListRowActions";
    };
    readonly propDefs: {
        readonly children: {};
        readonly description: {};
        readonly icon: {};
        readonly menuItems: {};
        readonly customActions: {};
        readonly className: {};
    };
};

/** @public */
type SelectSearch<T> = true | {
    mode?: 'client';
    inputValue?: never;
    defaultInputValue?: string;
    onInputChange?: (value: string) => void;
    filter?: (item: T, query: string) => boolean;
    placeholder?: string;
} | {
    mode?: 'client';
    inputValue: string;
    defaultInputValue?: never;
    onInputChange: (value: string) => void;
    filter?: (item: T, query: string) => boolean;
    placeholder?: string;
} | {
    mode: 'server';
    inputValue: string;
    defaultInputValue?: never;
    onInputChange: (value: string) => void;
    filter?: never;
    placeholder?: string;
};
/** @public */
type SelectAsyncSearch<T> = true | {
    mode?: 'client';
    inputValue?: never;
    defaultInputValue?: string;
    onInputChange?: (value: string) => void;
    filter?: (item: T, query: string) => boolean;
    placeholder?: string;
} | {
    mode?: 'client';
    inputValue: string;
    defaultInputValue?: never;
    onInputChange: (value: string) => void;
    filter?: (item: T, query: string) => boolean;
    placeholder?: string;
} | {
    mode: 'server';
    inputValue?: never;
    defaultInputValue?: never;
    onInputChange?: never;
    filter?: never;
    placeholder?: string;
};
/** @public */
type SelectStaticSearch = true | {
    mode?: 'client';
    inputValue?: never;
    defaultInputValue?: string;
    onInputChange?: (value: string) => void;
    filter?: never;
    placeholder?: string;
} | {
    mode?: 'client';
    inputValue: string;
    defaultInputValue?: never;
    onInputChange: (value: string) => void;
    filter?: never;
    placeholder?: string;
};
/** @public */
type SelectBaseOwnProps = {
    /**
     * An icon to render before the input
     */
    icon?: ReactNode;
    /**
     * The size of the select field
     * @defaultValue 'small'
     */
    size?: 'small' | 'medium' | Partial<Record<Breakpoint, 'small' | 'medium'>>;
    label?: FieldLabelProps['label'];
    secondaryLabel?: FieldLabelProps['secondaryLabel'];
    description?: FieldLabelProps['description'];
    isRequired?: boolean;
    className?: string;
};
/** @public */
type SelectOwnProps = SelectBaseOwnProps & {
    options?: ReadonlyArray<Option | OptionSection> | AsyncListSource<IdentifiedOption>;
    items?: Iterable<{
        id: Key;
    }> | AsyncListSource<{
        id: Key;
    }>;
    children?: ReactElement | ReactElement[] | ((item: {
        id: Key;
    }) => ReactElement);
    dependencies?: ReadonlyArray<unknown>;
    search?: SelectSearch<{
        id: Key;
    }> | SelectAsyncSearch<{
        id: Key;
    }>;
    searchable?: boolean;
    searchPlaceholder?: string;
    loading?: LoadingConfig;
};
/** @public */
type SelectCommonProps<T extends {
    id: Key;
}, M extends 'single' | 'multiple' = 'single' | 'multiple'> = SelectBaseOwnProps & Omit<SelectProps$1<T, M>, keyof SelectOwnProps | 'defaultItems'> & {
    /**
     * Selection mode, single or multiple
     * @defaultvalue 'single'
     */
    selectionMode?: M;
};
/** @public */
type SelectOptionsProps<M extends 'single' | 'multiple' = 'single' | 'multiple'> = SelectCommonProps<NormalizedOption, M> & {
    options?: ReadonlyArray<Option | OptionSection>;
    items?: never;
    children?: never;
    dependencies?: never;
    loading?: LoadingConfig;
} & ({
    search?: SelectSearch<NormalizedOption>;
    searchable?: never;
    searchPlaceholder?: never;
} | {
    search?: never;
    /** @deprecated Use search instead. */
    searchable?: boolean;
    /** @deprecated Use search.placeholder instead. */
    searchPlaceholder?: string;
});
/** @public */
type SelectAsyncOptionsProps<M extends 'single' | 'multiple' = 'single' | 'multiple'> = SelectCommonProps<NormalizedOption, M> & {
    options: AsyncListSource<IdentifiedOption>;
    items?: never;
    children?: never;
    dependencies?: never;
    loading?: never;
    search?: SelectAsyncSearch<NormalizedOption>;
    searchable?: never;
    searchPlaceholder?: never;
};
/** @public */
type SelectItemsProps<T extends {
    id: Key;
}, M extends 'single' | 'multiple' = 'single' | 'multiple'> = SelectCommonProps<T, M> & {
    options?: never;
    items: Iterable<T>;
    children: (item: T) => ReactElement;
    dependencies?: ReadonlyArray<unknown>;
    loading?: LoadingConfig;
    search?: SelectSearch<T>;
    searchable?: never;
    searchPlaceholder?: never;
};
/** @public */
type SelectAsyncItemsProps<T extends {
    id: Key;
}, M extends 'single' | 'multiple' = 'single' | 'multiple'> = SelectCommonProps<T, M> & {
    options?: never;
    items: AsyncListSource<T>;
    children: (item: T) => ReactElement;
    dependencies?: ReadonlyArray<unknown>;
    loading?: never;
    search?: SelectAsyncSearch<T>;
    searchable?: never;
    searchPlaceholder?: never;
};
/** @public */
type SelectStaticProps<M extends 'single' | 'multiple' = 'single' | 'multiple'> = SelectCommonProps<NormalizedOption, M> & {
    options?: never;
    items?: never;
    children: ReactElement | ReactElement[];
    dependencies?: never;
    search?: SelectStaticSearch;
    searchable?: never;
    searchPlaceholder?: never;
    loading?: never;
};
/** @public */
type SelectProps<M extends 'single' | 'multiple' = 'single' | 'multiple', T extends {
    id: Key;
} = NormalizedOption> = SelectOptionsProps<M> | SelectAsyncOptionsProps<M> | SelectItemsProps<T, M> | SelectAsyncItemsProps<T, M> | SelectStaticProps<M>;
/** @public */
type SelectItemOwnProps = {
    children: ReactNode | ((values: ListBoxItemRenderProps) => ReactNode);
    /**
     * Show the built-in selection indicator and standard item content layout.
     */
    showSelectionIndicator?: boolean;
    className?: string;
};
/** @public */
type SelectItemProps<T extends object = object> = SelectItemOwnProps & Omit<ListBoxItemProps<T>, keyof SelectItemOwnProps | 'textValue'> & {
    textValue: string;
};
/** @public */
type SelectItemTextOwnProps = {
    title: string;
    description?: string;
    leadingIcon?: ReactNode;
    className?: string;
};
/** @public */
type SelectItemTextProps<T extends object = object> = SelectItemTextOwnProps & Omit<SelectItemProps<T>, keyof SelectItemTextOwnProps | 'children' | 'textValue' | 'showSelectionIndicator'>;
/** @public */
type SelectItemProfileOwnProps = {
    name: string;
    src?: string;
    className?: string;
};
/** @public */
type SelectItemProfileProps<T extends object = object> = SelectItemProfileOwnProps & Omit<SelectItemProps<T>, keyof SelectItemProfileOwnProps | 'children' | 'textValue' | 'showSelectionIndicator'>;

/** @public */
declare const Select: {
    <M extends "single" | "multiple" = "single" | "multiple", T extends {
        id: Key;
    } = NormalizedOption>(props: SelectProps<M, T> & React.RefAttributes<HTMLDivElement>): React.ReactElement | null;
    displayName?: string;
};

/**
 * A low-level Select item wrapper for custom item content.
 *
 * @public
 */
declare function SelectItem<T extends object = object>(props: SelectItemProps<T>): react_jsx_runtime.JSX.Element;
/**
 * A Select item preset with a title and optional supporting content.
 *
 * @public
 */
declare function SelectItemText<T extends object = object>(props: SelectItemTextProps<T>): react_jsx_runtime.JSX.Element;
/**
 * A Select item preset for a person or other named profile.
 *
 * @public
 */
declare function SelectItemProfile<T extends object = object>(props: SelectItemProfileProps<T>): react_jsx_runtime.JSX.Element;

/** @public */
declare const SelectDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-Select";
        readonly popover: "bui-SelectPopover";
    };
    readonly propDefs: {
        readonly icon: {};
        readonly size: {
            readonly dataAttribute: true;
            readonly default: "small";
        };
        readonly options: {};
        readonly items: {};
        readonly children: {};
        readonly dependencies: {};
        readonly search: {};
        readonly loading: {};
        readonly searchable: {};
        readonly searchPlaceholder: {};
        readonly label: {};
        readonly secondaryLabel: {};
        readonly description: {};
        readonly isRequired: {};
        readonly className: {};
    };
};
/** @public */
declare const SelectTriggerDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-SelectTrigger";
        readonly chevron: "bui-SelectTriggerChevron";
        readonly value: "bui-SelectValue";
    };
    readonly bg: "consumer";
    readonly propDefs: {
        readonly icon: {};
    };
};
/** @public */
declare const SelectContentDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-SelectContent";
        readonly searchWrapper: "bui-SelectSearchWrapper";
        readonly results: "bui-SelectResults";
        readonly search: "bui-SelectSearch";
        readonly searchClear: "bui-SelectSearchClear";
    };
    readonly propDefs: {
        readonly search: {};
        readonly options: {};
        readonly items: {};
        readonly children: {};
        readonly dependencies: {};
        readonly loading: {};
        readonly isStale: {};
        readonly visibleIds: {};
        readonly retainedOptions: {};
    };
};
/** @public */
declare const SelectListBoxDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-SelectList";
        readonly noResults: "bui-SelectNoResults";
        readonly loading: "bui-SelectLoading";
        readonly loadingRow: "bui-SelectLoadingRow";
    };
    readonly propDefs: {
        readonly options: {};
        readonly items: {};
        readonly children: {};
        readonly dependencies: {};
        readonly loading: {};
        readonly isStale: {};
        readonly retainedOptions: {};
    };
};
/** @public */
declare const SelectListBoxItemDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly label: "bui-SelectItemLabel";
    };
    readonly propDefs: {};
};
/** @public */
declare const SelectItemDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-SelectItem";
        readonly indicator: "bui-SelectItemIndicator";
        readonly content: "bui-SelectItemContent";
    };
    readonly propDefs: {
        readonly children: {};
        readonly showSelectionIndicator: {};
        readonly className: {};
    };
};
/** @public */
declare const SelectItemTextDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-SelectItemText";
        readonly content: "bui-SelectItemContent";
        readonly leadingIcon: "bui-SelectItemLeadingIcon";
        readonly text: "bui-SelectItemTextContent";
        readonly title: "bui-SelectItemTitle";
        readonly description: "bui-SelectItemDescription";
    };
    readonly propDefs: {
        readonly title: {};
        readonly description: {};
        readonly leadingIcon: {};
        readonly className: {};
    };
};
/** @public */
declare const SelectItemProfileDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-SelectItemProfile";
        readonly content: "bui-SelectItemContent";
        readonly avatar: "bui-SelectItemAvatar";
        readonly name: "bui-SelectItemTitle";
    };
    readonly propDefs: {
        readonly name: {};
        readonly src: {};
        readonly className: {};
    };
};
/** @public */
declare const SelectSectionDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-SelectSection";
        readonly header: "bui-SelectSectionHeader";
    };
    readonly propDefs: {};
};

/** @public */
type SkeletonOwnProps = {
    width?: number | string;
    height?: number | string;
    rounded?: boolean;
    className?: string;
    style?: React.CSSProperties;
};
/** @public */
interface SkeletonProps extends Omit<ComponentProps<'div'>, 'children' | 'className' | 'style'>, SkeletonOwnProps {
}

/**
 * A placeholder shape displayed while content is loading, matching the size and layout of the content it replaces.
 *
 * @public
 */
declare const Skeleton: (props: SkeletonProps) => react_jsx_runtime.JSX.Element;

/**
 * Component definition for Skeleton
 * @public
 */
declare const SkeletonDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-Skeleton";
    };
    readonly bg: "consumer";
    readonly propDefs: {
        readonly width: {
            readonly default: 80;
        };
        readonly height: {
            readonly default: 24;
        };
        readonly rounded: {
            readonly dataAttribute: true;
            readonly default: false;
        };
        readonly className: {};
        readonly style: {};
    };
};

/** @public */
type SwitchOwnProps = {
    /**
     * The label of the switch
     */
    label?: string;
    className?: string;
};
/** @public */
interface SwitchProps extends Omit<SwitchProps$1, 'className'>, SwitchOwnProps {
}

/**
 * A toggle control for switching between on and off states, with an optional visible label.
 *
 * @public
 */
declare const Switch: react.ForwardRefExoticComponent<SwitchProps & react.RefAttributes<HTMLLabelElement>>;

/**
 * Component definition for Switch
 * @public
 */
declare const SwitchDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-Switch";
        readonly indicator: "bui-SwitchIndicator";
    };
    readonly bg: "consumer";
    readonly propDefs: {
        readonly label: {};
        readonly className: {};
    };
};

/** @public */
type ToggleButtonOwnProps = {
    size?: 'small' | 'medium' | Partial<Record<Breakpoint, 'small' | 'medium'>>;
    iconStart?: ReactElement;
    iconEnd?: ReactElement;
    children?: ToggleButtonProps$1['children'];
    className?: string;
};
/**
 * Properties for {@link ToggleButton}
 *
 * @public
 */
interface ToggleButtonProps extends Omit<ToggleButtonProps$1, 'children' | 'className'>, ToggleButtonOwnProps {
}

/**
 * A button that maintains a pressed or unpressed state, with optional start and end icon slots.
 *
 * @public
 */
declare const ToggleButton: react.ForwardRefExoticComponent<ToggleButtonProps & react.RefAttributes<HTMLButtonElement>>;

/**
 * Component definition for ToggleButton
 * @public
 */
declare const ToggleButtonDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-ToggleButton";
        readonly content: "bui-ToggleButtonContent";
    };
    readonly propDefs: {
        readonly size: {
            readonly dataAttribute: true;
            readonly default: "small";
        };
        readonly iconStart: {};
        readonly iconEnd: {};
        readonly children: {};
        readonly className: {};
    };
};

/** @public */
type ToggleButtonGroupOwnProps = {
    className?: string;
    children?: ReactNode;
};
/** @public */
interface ToggleButtonGroupProps extends Omit<ToggleButtonGroupProps$1, 'className' | 'children'>, ToggleButtonGroupOwnProps {
}

/**
 * A container that groups ToggleButton items and manages their collective selection state.
 *
 * @public
 */
declare const ToggleButtonGroup: react.ForwardRefExoticComponent<ToggleButtonGroupProps & react.RefAttributes<HTMLDivElement>>;

/**
 * Component definition for ToggleButtonGroup
 * @public
 */
declare const ToggleButtonGroupDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-ToggleButtonGroup";
    };
    readonly propDefs: {
        readonly className: {};
        readonly children: {};
    };
};

/** @public */
type VisuallyHiddenOwnProps = {
    className?: string;
};
/**
 * Properties for {@link VisuallyHidden}
 *
 * @public
 */
interface VisuallyHiddenProps extends Omit<ComponentProps<'div'>, 'className'>, VisuallyHiddenOwnProps {
}

/**
 * Visually hides content while keeping it accessible to screen readers.
 * Useful for descriptive labels and other screen-reader-only content.
 *
 * Note: This component is for content that should ALWAYS remain visually hidden.
 * For skip links that become visible on focus, use a different approach.
 *
 * @public
 */
declare const VisuallyHidden: (props: VisuallyHiddenProps) => react_jsx_runtime.JSX.Element;

/**
 * Component definition for VisuallyHidden
 * @public
 */
declare const VisuallyHiddenDefinition: {
    readonly styles: {
        readonly [key: string]: string;
    };
    readonly classNames: {
        readonly root: "bui-VisuallyHidden";
    };
    readonly propDefs: {
        readonly className: {};
    };
};

/** @public */
declare const useBreakpoint: () => {
    breakpoint: Breakpoint;
    up: (key: Breakpoint) => boolean;
    down: (key: Breakpoint) => boolean;
};

/** @public */
interface BgContextValue {
    bg: ContainerBg | undefined;
}
/** @public */
interface BgProviderProps {
    bg: ContainerBg;
    children: ReactNode;
}
/**
 * Provider component that establishes the bg context for child components.
 *
 * @public
 */
declare const BgProvider: ({ bg, children }: BgProviderProps) => react_jsx_runtime.JSX.Element;
/**
 * Hook for consumer components (e.g. Button) to read the parent bg context.
 *
 * Returns the parent container's bg unchanged. The consumer component's CSS
 * handles the visual step-up (e.g. on a neutral-1 surface, the consumer
 * uses neutral-2 tokens via `data-on-bg`).
 *
 * @public
 */
declare function useBgConsumer(): BgContextValue;
/**
 * Hook for provider components (e.g. Box, Card) to resolve and provide bg context.
 *
 * **Resolution rules:**
 *
 * - `bg` is `undefined` -- transparent, no context change, returns `{ bg: undefined }`.
 *   This is the default for Box, Flex, and Grid (they do **not** auto-increment).
 * - `bg` is `'neutral'` -- when the parent bg is neutral, increments the neutral
 *   level from the parent context, capping at `neutral-3`. When the parent bg is
 *   an intent (`'danger'` | `'warning'` | `'success'`), the intent passes through
 *   unchanged (i.e. `bg: 'neutral'` does not override the parent intent). The
 *   increment is always relative to the parent; it is not possible to pin a
 *   container to an explicit neutral level.
 * - `bg` is `'danger'` | `'warning'` | `'success'` -- sets the bg to that intent
 *   explicitly, regardless of the parent value.
 *
 * **Capping:**
 *
 * Provider components cap at `neutral-3`. The `neutral-4` level is **not** a valid
 * prop value -- it exists only in consumer component CSS (e.g. a Button on a
 * `neutral-3` surface renders with `neutral-4` tokens via `data-on-bg`).
 *
 * The caller is responsible for wrapping children with `BgProvider` when the
 * resolved bg is defined.
 *
 * @public
 */
declare function useBgProvider(bg?: Responsive<ProviderBg>): BgContextValue;

/**
 * Key-value metadata attached to analytics events.
 * @public
 */
type AnalyticsEventAttributes = {
    [key: string]: string | boolean | number;
};
/**
 * A generic interface for capturing analytics events. Consumers provide
 * an implementation via `BUIProvider` — this allows `@backstage/ui`
 * to fire analytics events without depending on any specific analytics
 * system. The signature intentionally matches Backstage's own
 * `AnalyticsTracker` so it can be wired through directly.
 * @public
 */
type AnalyticsTracker = {
    captureEvent: (action: string, subject: string, options?: {
        value?: number;
        attributes?: AnalyticsEventAttributes;
    }) => void;
};
/**
 * A hook function that returns an AnalyticsTracker.
 * Provided via context by the consumer (e.g. a Backstage app).
 * @public
 */
type UseAnalyticsFn = () => AnalyticsTracker;

/** @public */
type BUIProviderProps = {
    useAnalytics?: UseAnalyticsFn;
    children: ReactNode;
};
/**
 * Provides integration capabilities to all descendant BUI components.
 *
 * @example
 * ```tsx
 * import { BUIProvider } from '@backstage/ui';
 * import { useAnalytics as useBackstageAnalytics } from '@backstage/core-plugin-api';
 *
 * function App() {
 *   return (
 *     <BUIProvider useAnalytics={useBackstageAnalytics}>
 *       <AppContent />
 *     </BUIProvider>
 *   );
 * }
 * ```
 *
 * @public
 */
declare function BUIProvider(props: BUIProviderProps): react_jsx_runtime.JSX.Element;

/**
 * Returns an AnalyticsTracker for capturing analytics events.
 *
 * By default returns a noop tracker. When a `BUIProvider` is present
 * in the tree, returns the tracker provided by the consumer's hook.
 *
 * @public
 */
declare function useAnalytics(): AnalyticsTracker;

/**
 * Recursively extracts text content from a React node tree.
 * Returns undefined if no text content is found (e.g. icon-only children
 * or render functions).
 *
 * @public
 */
declare function getNodeText(node: ReactNode | ((...args: any[]) => ReactNode)): string | undefined;

export { Accordion, AccordionDefinition, AccordionGroup, AccordionGroupDefinition, AccordionPanel, AccordionPanelDefinition, AccordionTrigger, AccordionTriggerDefinition, Alert, AlertDefinition, Avatar, AvatarDefinition, BUIProvider, Badge, BadgeDefinition, BgProvider, Box, BoxDefinition, Button, ButtonDefinition, ButtonIcon, ButtonIconDefinition, ButtonLink, ButtonLinkDefinition, Card, CardBody, CardBodyDefinition, CardDefinition, CardFooter, CardFooterDefinition, CardHeader, CardHeaderDefinition, Cell, CellProfile, CellText, Checkbox, CheckboxDefinition, CheckboxGroup, CheckboxGroupDefinition, Column, Combobox, ComboboxDefinition, ComboboxInputDefinition, ComboboxItem, ComboboxItemDefinition, ComboboxItemProfile, ComboboxItemProfileDefinition, ComboboxItemText, ComboboxItemTextDefinition, ComboboxListBoxDefinition, ComboboxListBoxItemDefinition, ComboboxSectionDefinition, Container, ContainerDefinition, DatePicker, DatePickerCalendarDefinition, DatePickerDefinition, DatePickerGroupDefinition, DateRangePicker, DateRangePickerDefinition, Dialog, DialogBody, DialogBodyDefinition, DialogDefinition, DialogFooter, DialogFooterDefinition, DialogHeader, DialogHeaderDefinition, DialogTrigger, FieldLabel, FieldLabelDefinition, Flex, FlexDefinition, FullPage, FullPageDefinition, Grid, GridDefinition, GridItemDefinition, Header, HeaderDefinition, HeaderMetadataStatus, HeaderMetadataUsers, HeaderNavDefinition, HeaderNavGroupDefinition, HeaderNavItemDefinition, HeaderPage, HeaderPageDefinition, Link, LinkDefinition, List, ListDefinition, ListRow, ListRowDefinition, Menu, MenuAutocomplete, MenuAutocompleteListbox, MenuDefinition, MenuItem, MenuListBox, MenuListBoxItem, MenuSection, MenuSeparator, MenuTrigger, NumberField, NumberFieldDefinition, PasswordField, PasswordFieldDefinition, PluginHeader, PluginHeaderDefinition, Popover, PopoverDefinition, Radio, RadioDefinition, RadioGroup, RadioGroupDefinition, Row, SearchAutocomplete, SearchAutocompleteDefinition, SearchAutocompleteItem, SearchField, SearchFieldDefinition, Select, SelectContentDefinition, SelectDefinition, SelectItem, SelectItemDefinition, SelectItemProfile, SelectItemProfileDefinition, SelectItemText, SelectItemTextDefinition, SelectListBoxDefinition, SelectListBoxItemDefinition, SelectSectionDefinition, SelectTriggerDefinition, Skeleton, SkeletonDefinition, Slider, SliderDefinition, SubmenuTrigger, Switch, SwitchDefinition, Tab, TabList, TabPanel, Table, TableBody, TableBodySkeleton, TableDefinition, TableHeader, TablePagination, TablePaginationDefinition, TableRoot, Tabs, TabsDefinition, Tag, TagGroup, TagGroupDefinition, Text, TextDefinition, TextField, TextFieldDefinition, ToggleButton, ToggleButtonDefinition, ToggleButtonGroup, ToggleButtonGroupDefinition, Tooltip, TooltipDefinition, TooltipTrigger, VisuallyHidden, VisuallyHiddenDefinition, getNodeText, useAnalytics, useBgConsumer, useBgProvider, useBreakpoint, useTable };
export type { AccordionGroupOwnProps, AccordionGroupProps, AccordionOwnProps, AccordionPanelOwnProps, AccordionPanelProps, AccordionProps, AccordionTriggerOwnProps, AccordionTriggerProps, AlertOwnProps, AlertProps, AlignItems, AnalyticsEventAttributes, AnalyticsTracker, AsyncListSource, AvatarOwnProps, AvatarProps, BUIProviderProps, BadgeOwnProps, BadgeProps, BgContextValue, BgProviderProps, Border, BorderRadius, BoxOwnProps, BoxProps, BoxUtilityProps, Breakpoint, ButtonIconOwnProps, ButtonIconProps, ButtonLinkOwnProps, ButtonLinkProps, ButtonOwnProps, ButtonProps, CardBaseProps, CardBodyOwnProps, CardBodyProps, CardButtonVariant, CardFooterOwnProps, CardFooterProps, CardHeaderOwnProps, CardHeaderProps, CardLinkVariant, CardOwnProps, CardProps, CardStaticVariant, CellOwnProps, CellProfileOwnProps, CellProfileProps, CellProps, CellTextOwnProps, CellTextProps, CheckboxGroupOwnProps, CheckboxGroupProps, CheckboxOwnProps, CheckboxProps, ColumnConfig, ColumnOwnProps, ColumnProps, Columns, ComboboxAsyncItemsProps, ComboboxAsyncOptionsProps, ComboboxAsyncSearch, ComboboxBaseOwnProps, ComboboxCommonProps, ComboboxItemOwnProps, ComboboxItemProfileOwnProps, ComboboxItemProfileProps, ComboboxItemProps, ComboboxItemSelectionProps, ComboboxItemTextOwnProps, ComboboxItemTextProps, ComboboxItemsProps, ComboboxKeySelectionProps, ComboboxOptionsProps, ComboboxOwnProps, ComboboxProps, ComboboxSearch, ComboboxServerItem, ComboboxServerItemsProps, ComboboxServerOptionsProps, ComboboxStaticProps, ComboboxStaticSearch, CompletePaginationOptions, ContainerBg, ContainerOwnProps, ContainerProps, CursorParams, CursorResponse, DatePickerOwnProps, DatePickerProps, DateRangePickerOwnProps, DateRangePickerProps, DialogBodyOwnProps, DialogBodyProps, DialogFooterOwnProps, DialogFooterProps, DialogHeaderOwnProps, DialogHeaderProps, DialogOwnProps, DialogProps, DialogTriggerProps, Display, FieldLabelOwnProps, FieldLabelProps, FilterState, FlexDirection, FlexItemProps, FlexOwnProps, FlexProps, FlexWrap, FullPageOwnProps, FullPageProps, GridItemOwnProps, GridItemProps, GridOwnProps, GridProps, HeaderBreadcrumb, HeaderMetadataItem, HeaderMetadataStatusProps, HeaderMetadataUser, HeaderNavTab, HeaderNavTabGroup, HeaderNavTabItem, HeaderOwnProps, HeaderPageBreadcrumb, HeaderPageOwnProps, HeaderPageProps, HeaderProps, HeaderTab, HeaderTag, IdentifiedOption, JustifyContent, LegacyOption, LinkOwnProps, LinkProps, ListOwnProps, ListProps, ListRowOwnProps, ListRowProps, LoadingConfig, LoadingState, MarginProps, MenuAutocompleteListBoxOwnProps, MenuAutocompleteListBoxProps, MenuAutocompleteOwnProps, MenuAutocompleteProps, MenuItemOwnProps, MenuItemProps, MenuListBoxItemOwnProps, MenuListBoxItemProps, MenuListBoxOwnProps, MenuListBoxProps, MenuOwnProps, MenuPopoverOwnProps, MenuProps, MenuSectionOwnProps, MenuSectionProps, MenuSeparatorOwnProps, MenuSeparatorProps, MenuTriggerProps, NoPagination, NormalizedOption, NumberFieldOwnProps, NumberFieldProps, OffsetParams, OffsetResponse, Option, OptionSection, PaddingProps, PagePagination, PageSizeOption, PaginationOptions, PasswordFieldOwnProps, PasswordFieldProps, PluginHeaderOwnProps, PluginHeaderProps, PopoverOwnProps, PopoverProps, ProviderBg, QueryOptions, RadioGroupOwnProps, RadioGroupProps, RadioOwnProps, RadioProps, Responsive, RowConfig, RowOwnProps, RowProps, RowRenderFn, SearchAutocompleteItemOwnProps, SearchAutocompleteItemProps, SearchAutocompleteOwnProps, SearchAutocompleteProps, SearchFieldOwnProps, SearchFieldProps, SearchState, SelectAsyncItemsProps, SelectAsyncOptionsProps, SelectAsyncSearch, SelectBaseOwnProps, SelectCommonProps, SelectItemOwnProps, SelectItemProfileOwnProps, SelectItemProfileProps, SelectItemProps, SelectItemTextOwnProps, SelectItemTextProps, SelectItemsProps, SelectOptionsProps, SelectOwnProps, SelectProps, SelectSearch, SelectStaticProps, SelectStaticSearch, SkeletonOwnProps, SkeletonProps, SliderOwnProps, SliderProps, SortDescriptor, SortState, Space, SpaceProps, SubmenuTriggerProps, SwitchOwnProps, SwitchProps, TabListOwnProps, TabListProps, TabMatchStrategy, TabOwnProps, TabPanelOwnProps, TabPanelProps, TabProps, TableBodyOwnProps, TableBodyProps, TableHeaderOwnProps, TableHeaderProps, TableItem, TablePaginationOwnProps, TablePaginationProps, TablePaginationType, TableProps, TableRootOwnProps, TableRootProps, TableSelection, TabsOwnProps, TabsProps, TagGroupOwnProps, TagGroupProps, TagOwnProps, TagProps, TextColorStatus, TextColors, TextFieldOwnProps, TextFieldProps, TextOwnProps, TextProps, TextVariants, TextWeights, ToggleButtonGroupOwnProps, ToggleButtonGroupProps, ToggleButtonOwnProps, ToggleButtonProps, TooltipOwnProps, TooltipProps, UseAnalyticsFn, UseTableCompleteOptions, UseTableCursorOptions, UseTableOffsetOptions, UseTableOptions, UseTableResult, UtilityProps, VirtualizedProp, VisuallyHiddenOwnProps, VisuallyHiddenProps };