import React, { ReactNode, CSSProperties } from 'react';

type AccordionType = 'single' | 'multiple';
type AccordionProps = React.HTMLAttributes<HTMLDivElement> & {
    type?: AccordionType;
    value?: string | string[];
    defaultValue?: string | string[];
    onValueChange?: (value: string | string[]) => void;
};
type AccordionRootComponent = React.ForwardRefExoticComponent<Readonly<AccordionProps> & React.RefAttributes<HTMLDivElement>>;
declare const AccordionRoot: AccordionRootComponent;
type AccordionItemProps = React.HTMLAttributes<HTMLDivElement> & {
    value: string;
};
type AccordionItemComponent = React.ForwardRefExoticComponent<Readonly<AccordionItemProps> & React.RefAttributes<HTMLDivElement>>;
declare const AccordionItem: AccordionItemComponent;
type AccordionTriggerProps = React.ButtonHTMLAttributes<HTMLButtonElement>;
type AccordionTriggerComponent = React.ForwardRefExoticComponent<Readonly<AccordionTriggerProps> & React.RefAttributes<HTMLButtonElement>>;
declare const AccordionTrigger: AccordionTriggerComponent;
type AccordionContentProps = React.HTMLAttributes<HTMLDivElement>;
type AccordionContentComponent = React.ForwardRefExoticComponent<Readonly<AccordionContentProps> & React.RefAttributes<HTMLDivElement>>;
declare const AccordionContent: AccordionContentComponent;
type AccordionComponent = typeof AccordionRoot & {
    Item: typeof AccordionItem;
    Trigger: typeof AccordionTrigger;
    Content: typeof AccordionContent;
};
declare const Accordion: AccordionComponent;

type AlertVariant = 'error' | 'success' | 'warning' | 'info';
type AlertProps = {
    variant?: AlertVariant;
    title?: string;
    children: React.ReactNode;
    className?: string;
    style?: React.CSSProperties;
};
type AlertComponent = React.ForwardRefExoticComponent<Readonly<AlertProps> & React.RefAttributes<HTMLDivElement>>;
declare const Alert: AlertComponent;

type AvatarSize = 'sm' | 'md' | 'lg';
type AvatarStatus = 'online' | 'offline' | 'idle' | 'dnd';
type AvatarProps = React.HTMLAttributes<HTMLSpanElement> & {
    src?: string;
    alt?: string;
    fallback?: string;
    size?: AvatarSize;
    status?: AvatarStatus;
};
type AvatarComponent = React.ForwardRefExoticComponent<Readonly<AvatarProps> & React.RefAttributes<HTMLSpanElement>>;
declare const Avatar: AvatarComponent;

type BadgeTone = 'neutral' | 'info' | 'success' | 'warning' | 'error';
type BadgeVariant = 'subtle' | 'solid';
type BadgeSize = 'sm' | 'md';
type BadgeProps = React.HTMLAttributes<HTMLSpanElement> & {
    tone?: BadgeTone;
    variant?: BadgeVariant;
    size?: BadgeSize;
};
type BadgeComponent = React.ForwardRefExoticComponent<Readonly<BadgeProps> & React.RefAttributes<HTMLSpanElement>>;
declare const Badge: BadgeComponent;

type PolymorphicRef<Element extends React.ElementType> = React.ComponentPropsWithRef<Element>['ref'];
type PolymorphicComponentProps<Element extends React.ElementType, OwnProps extends object = Record<string, never>> = OwnProps & {
    as?: Element;
} & Omit<React.ComponentPropsWithoutRef<Element>, keyof OwnProps | 'as'>;

type SpaceToken = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '8' | '10' | '12' | '16';
type RadiusToken = 'none' | 'sm' | 'md' | 'lg' | 'full';
type ColorToken = 'surface' | 'surface-subtle' | 'surface-hover' | 'surface-active' | 'text' | 'text-primary' | 'text-secondary' | 'text-muted' | 'text-title' | 'border' | 'border-muted' | 'border-subtle' | 'primary' | 'info' | 'success' | 'warning' | 'error';
type BoxElement = 'div' | 'span' | 'section' | 'article' | 'main' | 'aside' | 'header' | 'footer' | 'nav' | 'a' | 'button' | 'ul' | 'ol' | 'li' | 'p';
type BoxBaseProps = {
    p?: SpaceToken;
    px?: SpaceToken;
    py?: SpaceToken;
    pt?: SpaceToken;
    pr?: SpaceToken;
    pb?: SpaceToken;
    pl?: SpaceToken;
    m?: SpaceToken;
    mx?: SpaceToken;
    my?: SpaceToken;
    mt?: SpaceToken;
    mr?: SpaceToken;
    mb?: SpaceToken;
    ml?: SpaceToken;
    gap?: SpaceToken;
    rowGap?: SpaceToken;
    columnGap?: SpaceToken;
    bg?: ColorToken;
    color?: ColorToken;
    borderColor?: ColorToken;
    radius?: RadiusToken;
    display?: React.CSSProperties['display'];
    width?: React.CSSProperties['width'];
    minWidth?: React.CSSProperties['minWidth'];
    maxWidth?: React.CSSProperties['maxWidth'];
    height?: React.CSSProperties['height'];
    minHeight?: React.CSSProperties['minHeight'];
    maxHeight?: React.CSSProperties['maxHeight'];
    className?: string;
    style?: React.CSSProperties;
};
type BoxProps<E extends BoxElement = 'div'> = PolymorphicComponentProps<E, BoxBaseProps>;
type BoxComponent = (<E extends BoxElement = 'div'>(props: Readonly<BoxProps<E>> & {
    ref?: PolymorphicRef<E>;
}) => React.ReactElement | null) & {
    displayName?: string;
};
declare const Box: BoxComponent;

type LinkColor = 'primary' | 'text' | 'muted' | 'info' | 'success' | 'warning' | 'error';
type LinkUnderline = 'always' | 'hover' | 'none';
type LinkProps = React.AnchorHTMLAttributes<HTMLAnchorElement> & {
    color?: LinkColor;
    underline?: LinkUnderline;
};
type LinkComponent = React.ForwardRefExoticComponent<Readonly<LinkProps> & React.RefAttributes<HTMLAnchorElement>>;
declare const Link: LinkComponent;

type BreadcrumbsProps = React.HTMLAttributes<HTMLElement> & {
    separator?: string;
    ariaLabel?: string;
};
type BreadcrumbsListProps = React.OlHTMLAttributes<HTMLOListElement>;
type BreadcrumbsItemProps = React.LiHTMLAttributes<HTMLLIElement>;
type BreadcrumbsLinkProps = LinkProps;
type BreadcrumbsCurrentProps = React.HTMLAttributes<HTMLSpanElement>;
type BreadcrumbsRootComponent = React.ForwardRefExoticComponent<Readonly<BreadcrumbsProps> & React.RefAttributes<HTMLElement>>;
declare const BreadcrumbsRoot: BreadcrumbsRootComponent;
type BreadcrumbsListComponent = React.ForwardRefExoticComponent<Readonly<BreadcrumbsListProps> & React.RefAttributes<HTMLOListElement>>;
declare const BreadcrumbsList: BreadcrumbsListComponent;
type BreadcrumbsItemComponent = React.ForwardRefExoticComponent<Readonly<BreadcrumbsItemProps> & React.RefAttributes<HTMLLIElement>>;
declare const BreadcrumbsItem: BreadcrumbsItemComponent;
type BreadcrumbsLinkComponent = React.ForwardRefExoticComponent<Readonly<BreadcrumbsLinkProps> & React.RefAttributes<HTMLAnchorElement>>;
declare const BreadcrumbsLink: BreadcrumbsLinkComponent;
type BreadcrumbsCurrentComponent = React.ForwardRefExoticComponent<Readonly<BreadcrumbsCurrentProps> & React.RefAttributes<HTMLSpanElement>>;
declare const BreadcrumbsCurrent: BreadcrumbsCurrentComponent;
type BreadcrumbsComponent = typeof BreadcrumbsRoot & {
    List: typeof BreadcrumbsList;
    Item: typeof BreadcrumbsItem;
    Link: typeof BreadcrumbsLink;
    Current: typeof BreadcrumbsCurrent;
};
declare const Breadcrumbs: BreadcrumbsComponent;

type ButtonVariant = 'primary' | 'secondary' | 'ghost' | 'destructive';
type ButtonSize = 'sm' | 'md' | 'lg';
type ButtonBaseProps = {
    variant?: ButtonVariant;
    size?: ButtonSize;
    loading?: boolean;
    disabled?: boolean;
    asChild?: boolean;
    className?: string;
    style?: React.CSSProperties;
};
type ButtonProps = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'children' | 'className' | 'style' | 'disabled'> & ButtonBaseProps & {
    children: React.ReactNode;
};
type ButtonComponent = React.ForwardRefExoticComponent<Readonly<ButtonProps> & React.RefAttributes<HTMLButtonElement>>;
declare const Button: ButtonComponent;

type CardProps = React.HTMLAttributes<HTMLDivElement>;
type CardRootComponent = React.ForwardRefExoticComponent<Readonly<CardProps> & React.RefAttributes<HTMLDivElement>>;
declare const CardRoot: CardRootComponent;
type CardHeaderProps = React.HTMLAttributes<HTMLDivElement>;
type CardHeaderComponent = React.ForwardRefExoticComponent<Readonly<CardHeaderProps> & React.RefAttributes<HTMLDivElement>>;
declare const CardHeader: CardHeaderComponent;
type CardTitleProps = React.HTMLAttributes<HTMLHeadingElement>;
type CardTitleComponent = React.ForwardRefExoticComponent<Readonly<CardTitleProps> & React.RefAttributes<HTMLHeadingElement>>;
declare const CardTitle: CardTitleComponent;
type CardContentProps = React.HTMLAttributes<HTMLDivElement>;
type CardContentComponent = React.ForwardRefExoticComponent<Readonly<CardContentProps> & React.RefAttributes<HTMLDivElement>>;
declare const CardContent: CardContentComponent;
type CardFooterProps = React.HTMLAttributes<HTMLDivElement>;
type CardFooterComponent = React.ForwardRefExoticComponent<Readonly<CardFooterProps> & React.RefAttributes<HTMLDivElement>>;
declare const CardFooter: CardFooterComponent;
type CardComponent = typeof CardRoot & {
    Header: typeof CardHeader;
    Title: typeof CardTitle;
    Content: typeof CardContent;
    Footer: typeof CardFooter;
};
declare const Card: CardComponent;

type CheckboxSize = 'sm' | 'md' | 'lg';
type CheckboxProps = Omit<React.InputHTMLAttributes<HTMLInputElement>, 'type' | 'size' | 'className' | 'style'> & {
    label: string;
    hideLabel?: boolean;
    size?: CheckboxSize;
    indeterminate?: boolean;
    className?: string;
    style?: React.CSSProperties;
};
type CheckboxComponent = React.ForwardRefExoticComponent<Readonly<CheckboxProps> & React.RefAttributes<HTMLInputElement>>;
declare const Checkbox: CheckboxComponent;

type Variant = 'default' | 'outlined';
type ChipElement = 'button' | 'div' | 'span' | 'a';
type ChipElementNode<E extends ChipElement> = E extends 'button' ? HTMLButtonElement : E extends 'a' ? HTMLAnchorElement : E extends 'div' ? HTMLDivElement : HTMLSpanElement;
type ChipBaseProps = {
    label: string;
    variant?: Variant;
    style?: React.CSSProperties;
    className?: string;
};
type ChipProps<E extends ChipElement = 'span'> = PolymorphicComponentProps<E, ChipBaseProps & {
    onClick?: React.MouseEventHandler<ChipElementNode<E>>;
    children?: never;
}>;
type ChipComponent = (<E extends ChipElement = 'span'>(props: Readonly<ChipProps<E>> & {
    ref?: React.Ref<ChipElementNode<E>>;
}) => React.ReactElement | null) & {
    displayName?: string;
};
declare const Chip: ChipComponent;

type ComboboxSize = 'sm' | 'md' | 'lg';
type ComboboxOption = {
    value: string;
    label: string;
    disabled?: boolean;
};
type ComboboxProps = Omit<React.InputHTMLAttributes<HTMLInputElement>, 'type' | 'size' | 'className' | 'style' | 'value' | 'defaultValue' | 'onChange'> & {
    label: string;
    options: ReadonlyArray<ComboboxOption>;
    hideLabel?: boolean;
    error?: string;
    helperText?: string;
    size?: ComboboxSize;
    value?: string;
    defaultValue?: string;
    onChange?: React.ChangeEventHandler<HTMLInputElement>;
    noResultsText?: string;
    className?: string;
    style?: React.CSSProperties;
};
type ComboboxComponent = React.ForwardRefExoticComponent<Readonly<ComboboxProps> & React.RefAttributes<HTMLInputElement>>;
declare const Combobox: ComboboxComponent;

type DialogProps = {
    open?: boolean;
    defaultOpen?: boolean;
    onOpenChange?: (open: boolean) => void;
    children: React.ReactNode;
};
type DialogRootComponent = {
    (props: Readonly<DialogProps>): React.JSX.Element;
    displayName?: string;
};
declare const DialogRoot: DialogRootComponent;
type DialogTriggerProps = {
    children: React.ReactNode;
    asChild?: boolean;
} & Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'children'>;
type DialogTriggerComponent = React.ForwardRefExoticComponent<Readonly<DialogTriggerProps> & React.RefAttributes<HTMLElement>>;
declare const DialogTrigger: DialogTriggerComponent;
type DialogContentProps = React.HTMLAttributes<HTMLDivElement> & {
    closeLabel?: string;
    closeOnEscape?: boolean;
    closeOnOverlayClick?: boolean;
    hideCloseButton?: boolean;
    containerClassName?: string;
};
type DialogContentComponent = React.ForwardRefExoticComponent<Readonly<DialogContentProps> & React.RefAttributes<HTMLDialogElement>>;
declare const DialogContent: DialogContentComponent;
type DialogHeaderProps = React.HTMLAttributes<HTMLDivElement>;
type DialogHeaderComponent = React.ForwardRefExoticComponent<Readonly<DialogHeaderProps> & React.RefAttributes<HTMLDivElement>>;
declare const DialogHeader: DialogHeaderComponent;
type DialogTitleProps = React.HTMLAttributes<HTMLHeadingElement>;
type DialogTitleComponent = React.ForwardRefExoticComponent<Readonly<DialogTitleProps> & React.RefAttributes<HTMLHeadingElement>>;
declare const DialogTitle: DialogTitleComponent;
type DialogDescriptionProps = React.HTMLAttributes<HTMLParagraphElement>;
type DialogDescriptionComponent = React.ForwardRefExoticComponent<Readonly<DialogDescriptionProps> & React.RefAttributes<HTMLParagraphElement>>;
declare const DialogDescription: DialogDescriptionComponent;
type DialogBodyProps = React.HTMLAttributes<HTMLDivElement>;
type DialogBodyComponent = React.ForwardRefExoticComponent<Readonly<DialogBodyProps> & React.RefAttributes<HTMLDivElement>>;
declare const DialogBody: DialogBodyComponent;
type DialogFooterProps = React.HTMLAttributes<HTMLDivElement>;
type DialogFooterComponent = React.ForwardRefExoticComponent<Readonly<DialogFooterProps> & React.RefAttributes<HTMLDivElement>>;
declare const DialogFooter: DialogFooterComponent;
type DialogComponent = typeof DialogRoot & {
    Trigger: typeof DialogTrigger;
    Content: typeof DialogContent;
    Header: typeof DialogHeader;
    Title: typeof DialogTitle;
    Description: typeof DialogDescription;
    Body: typeof DialogBody;
    Footer: typeof DialogFooter;
};
declare const Dialog: DialogComponent;

type CommandPaletteProps = {
    open?: boolean;
    defaultOpen?: boolean;
    onOpenChange?: (open: boolean) => void;
    onSelect?: (value: string) => void;
    children: React.ReactNode;
};
type CommandPaletteRootComponent = {
    (props: Readonly<CommandPaletteProps>): React.JSX.Element;
    displayName?: string;
};
declare const CommandPaletteRoot: CommandPaletteRootComponent;
type CommandPaletteTriggerProps = DialogTriggerProps;
type CommandPaletteTriggerComponent = React.ForwardRefExoticComponent<Readonly<CommandPaletteTriggerProps> & React.RefAttributes<HTMLElement>>;
declare const CommandPaletteTrigger: CommandPaletteTriggerComponent;
type CommandPaletteContentProps = DialogContentProps;
type CommandPaletteContentComponent = React.ForwardRefExoticComponent<Readonly<CommandPaletteContentProps> & React.RefAttributes<HTMLDialogElement>>;
declare const CommandPaletteContent: CommandPaletteContentComponent;
type CommandPaletteInputProps = Omit<React.InputHTMLAttributes<HTMLInputElement>, 'type' | 'value' | 'defaultValue' | 'id' | 'role' | 'className' | 'style'> & {
    label?: string;
    hideLabel?: boolean;
    className?: string;
    style?: React.CSSProperties;
};
type CommandPaletteInputComponent = React.ForwardRefExoticComponent<Readonly<CommandPaletteInputProps> & React.RefAttributes<HTMLInputElement>>;
declare const CommandPaletteInput: CommandPaletteInputComponent;
type CommandPaletteListProps = Omit<React.HTMLAttributes<HTMLDivElement>, 'id' | 'role'>;
type CommandPaletteListComponent = React.ForwardRefExoticComponent<Readonly<CommandPaletteListProps> & React.RefAttributes<HTMLDivElement>>;
declare const CommandPaletteList: CommandPaletteListComponent;
type CommandPaletteGroupProps = React.HTMLAttributes<HTMLDivElement> & {
    heading: string;
};
type CommandPaletteGroupComponent = React.ForwardRefExoticComponent<Readonly<CommandPaletteGroupProps> & React.RefAttributes<HTMLDivElement>>;
declare const CommandPaletteGroup: CommandPaletteGroupComponent;
type CommandPaletteItemProps = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'value' | 'onSelect' | 'className' | 'style'> & {
    value: string;
    searchText?: string;
    keywords?: ReadonlyArray<string>;
    onSelect?: (value: string) => void;
    className?: string;
    style?: React.CSSProperties;
};
type CommandPaletteItemComponent = React.ForwardRefExoticComponent<Readonly<CommandPaletteItemProps> & React.RefAttributes<HTMLButtonElement>>;
declare const CommandPaletteItem: CommandPaletteItemComponent;
type CommandPaletteEmptyProps = React.HTMLAttributes<HTMLParagraphElement>;
type CommandPaletteEmptyComponent = React.ForwardRefExoticComponent<Readonly<CommandPaletteEmptyProps> & React.RefAttributes<HTMLParagraphElement>>;
declare const CommandPaletteEmpty: CommandPaletteEmptyComponent;
type CommandPaletteShortcutProps = React.HTMLAttributes<HTMLElement>;
type CommandPaletteShortcutComponent = React.ForwardRefExoticComponent<Readonly<CommandPaletteShortcutProps> & React.RefAttributes<HTMLElement>>;
declare const CommandPaletteShortcut: CommandPaletteShortcutComponent;
type CommandPaletteComponent = typeof CommandPaletteRoot & {
    Trigger: typeof CommandPaletteTrigger;
    Content: typeof CommandPaletteContent;
    Input: typeof CommandPaletteInput;
    List: typeof CommandPaletteList;
    Group: typeof CommandPaletteGroup;
    Item: typeof CommandPaletteItem;
    Empty: typeof CommandPaletteEmpty;
    Shortcut: typeof CommandPaletteShortcut;
};
declare const CommandPalette: CommandPaletteComponent;

type DrawerPlacement = 'left' | 'right' | 'top' | 'bottom';
type DrawerProps = {
    open?: boolean;
    defaultOpen?: boolean;
    onOpenChange?: (open: boolean) => void;
    placement?: DrawerPlacement;
    children: React.ReactNode;
};
type DrawerRootComponent = {
    (props: Readonly<DrawerProps>): React.JSX.Element;
    displayName?: string;
};
declare const DrawerRoot: DrawerRootComponent;
type DrawerTriggerProps = DialogTriggerProps;
type DrawerTriggerComponent = React.ForwardRefExoticComponent<Readonly<DrawerTriggerProps> & React.RefAttributes<HTMLElement>>;
declare const DrawerTrigger: DrawerTriggerComponent;
type DrawerContentProps = DialogContentProps;
type DrawerContentComponent = React.ForwardRefExoticComponent<Readonly<DrawerContentProps> & React.RefAttributes<HTMLDialogElement>>;
declare const DrawerContent: DrawerContentComponent;
type DrawerHeaderProps = DialogHeaderProps;
type DrawerHeaderComponent = React.ForwardRefExoticComponent<Readonly<DrawerHeaderProps> & React.RefAttributes<HTMLDivElement>>;
declare const DrawerHeader: DrawerHeaderComponent;
type DrawerTitleProps = DialogTitleProps;
type DrawerTitleComponent = React.ForwardRefExoticComponent<Readonly<DrawerTitleProps> & React.RefAttributes<HTMLHeadingElement>>;
declare const DrawerTitle: DrawerTitleComponent;
type DrawerDescriptionProps = DialogDescriptionProps;
type DrawerDescriptionComponent = React.ForwardRefExoticComponent<Readonly<DrawerDescriptionProps> & React.RefAttributes<HTMLParagraphElement>>;
declare const DrawerDescription: DrawerDescriptionComponent;
type DrawerBodyProps = DialogBodyProps;
type DrawerBodyComponent = React.ForwardRefExoticComponent<Readonly<DrawerBodyProps> & React.RefAttributes<HTMLDivElement>>;
declare const DrawerBody: DrawerBodyComponent;
type DrawerFooterProps = DialogFooterProps;
type DrawerFooterComponent = React.ForwardRefExoticComponent<Readonly<DrawerFooterProps> & React.RefAttributes<HTMLDivElement>>;
declare const DrawerFooter: DrawerFooterComponent;
type DrawerComponent = typeof DrawerRoot & {
    Trigger: typeof DrawerTrigger;
    Content: typeof DrawerContent;
    Header: typeof DrawerHeader;
    Title: typeof DrawerTitle;
    Description: typeof DrawerDescription;
    Body: typeof DrawerBody;
    Footer: typeof DrawerFooter;
};
declare const Drawer: DrawerComponent;

type DropdownMenuPlacement = 'top' | 'right' | 'bottom' | 'left';
type DropdownMenuProps = {
    open?: boolean;
    defaultOpen?: boolean;
    onOpenChange?: (open: boolean) => void;
    placement?: DropdownMenuPlacement;
    offset?: number;
    closeOnEscape?: boolean;
    closeOnOutsideClick?: boolean;
    children: React.ReactNode;
};
type DropdownMenuRootComponent = {
    (props: Readonly<DropdownMenuProps>): React.JSX.Element;
    displayName?: string;
};
declare const DropdownMenuRoot: DropdownMenuRootComponent;
type DropdownMenuTriggerProps = {
    children: React.ReactNode;
    asChild?: boolean;
} & Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'children'>;
type DropdownMenuTriggerComponent = React.ForwardRefExoticComponent<Readonly<DropdownMenuTriggerProps> & React.RefAttributes<HTMLElement>>;
declare const DropdownMenuTrigger: DropdownMenuTriggerComponent;
type DropdownMenuContentProps = React.HTMLAttributes<HTMLDivElement>;
type DropdownMenuContentComponent = React.ForwardRefExoticComponent<Readonly<DropdownMenuContentProps> & React.RefAttributes<HTMLDivElement>>;
declare const DropdownMenuContent: DropdownMenuContentComponent;
type DropdownMenuItemProps = React.ButtonHTMLAttributes<HTMLButtonElement> & {
    destructive?: boolean;
    disabled?: boolean;
    onSelect?: () => void;
};
type DropdownMenuItemComponent = React.ForwardRefExoticComponent<Readonly<DropdownMenuItemProps> & React.RefAttributes<HTMLButtonElement>>;
declare const DropdownMenuItem: DropdownMenuItemComponent;
type DropdownMenuComponent = typeof DropdownMenuRoot & {
    Trigger: typeof DropdownMenuTrigger;
    Content: typeof DropdownMenuContent;
    Item: typeof DropdownMenuItem;
};
declare const DropdownMenu: DropdownMenuComponent;

type FieldRenderProps = {
    inputId: string;
    labelId: string;
    describedBy?: string;
    hasError: boolean;
};
type FieldProps = {
    children: (props: Readonly<FieldRenderProps>) => ReactNode;
    label: string;
    hideLabel?: boolean;
    error?: string;
    helperText?: string;
    required?: boolean;
    disabled?: boolean;
    id?: string;
    className?: string;
    style?: CSSProperties;
    labelElement?: 'label' | 'span';
};
declare function Field({ children, label, hideLabel, error, helperText, required, disabled, id, className, style, labelElement, }: Readonly<FieldProps>): ReactNode;

type FlexProps<E extends BoxElement = 'div'> = Omit<BoxProps<E>, 'display' | 'flexDirection' | 'alignItems' | 'justifyContent' | 'flexWrap' | 'inline' | 'direction' | 'align' | 'justify' | 'wrap'> & {
    inline?: boolean;
    direction?: React.CSSProperties['flexDirection'];
    align?: React.CSSProperties['alignItems'];
    justify?: React.CSSProperties['justifyContent'];
    wrap?: React.CSSProperties['flexWrap'];
};
type FlexComponent = (<E extends BoxElement = 'div'>(props: Readonly<FlexProps<E>> & {
    ref?: PolymorphicRef<E>;
}) => React.ReactElement | null) & {
    displayName?: string;
};
declare const Flex: FlexComponent;

type GridProps<E extends BoxElement = 'div'> = Omit<BoxProps<E>, 'display'> & {
    columns?: number | string;
    rows?: number | string;
    autoFlow?: React.CSSProperties['gridAutoFlow'];
    alignItems?: React.CSSProperties['alignItems'];
    justifyItems?: React.CSSProperties['justifyItems'];
};
type GridComponent = (<E extends BoxElement = 'div'>(props: Readonly<GridProps<E>> & {
    ref?: PolymorphicRef<E>;
}) => React.ReactElement | null) & {
    displayName?: string;
};
declare const Grid: GridComponent;

type IconSizeToken = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
type IconStrokeToken = 'thin' | 'regular' | 'bold';
type IconProps = {
    size?: IconSizeToken | number;
    strokeWidth?: IconStrokeToken | number;
    title?: string;
    className?: string;
    style?: React.CSSProperties;
};

declare function CheckIcon({ size, strokeWidth, title, className, style, }: Readonly<IconProps>): React.JSX.Element;

declare function ChevronDownIcon({ size, strokeWidth, title, className, style, }: Readonly<IconProps>): React.JSX.Element;

declare function CircleCheckIcon({ size, strokeWidth, title, className, style, }: Readonly<IconProps>): React.JSX.Element;

declare function CircleInfoIcon({ size, strokeWidth, title, className, style, }: Readonly<IconProps>): React.JSX.Element;

declare function CircleXIcon({ size, strokeWidth, title, className, style, }: Readonly<IconProps>): React.JSX.Element;

declare function CloseIcon({ size, strokeWidth, title, className, style, }: Readonly<IconProps>): React.JSX.Element;

declare function MinusIcon({ size, strokeWidth, title, className, style, }: Readonly<IconProps>): React.JSX.Element;

declare function TriangleAlertIcon({ size, strokeWidth, title, className, style, }: Readonly<IconProps>): React.JSX.Element;

type PaginationProps = Omit<React.HTMLAttributes<HTMLElement>, 'children' | 'onChange'> & {
    totalPages: number;
    page?: number;
    defaultPage?: number;
    onPageChange?: (page: number) => void;
    siblingCount?: number;
    boundaryCount?: number;
    disabled?: boolean;
    showControls?: boolean;
    previousLabel?: string;
    nextLabel?: string;
    ariaLabel?: string;
    className?: string;
    style?: React.CSSProperties;
};
type PaginationComponent = React.ForwardRefExoticComponent<Readonly<PaginationProps> & React.RefAttributes<HTMLElement>>;
declare const Pagination: PaginationComponent;

type PopoverPlacement = 'top' | 'right' | 'bottom' | 'left';
type PopoverProps = {
    open?: boolean;
    defaultOpen?: boolean;
    onOpenChange?: (open: boolean) => void;
    placement?: PopoverPlacement;
    offset?: number;
    closeOnEscape?: boolean;
    closeOnOutsideClick?: boolean;
    children: React.ReactNode;
};
type PopoverRootComponent = {
    (props: Readonly<PopoverProps>): React.JSX.Element;
    displayName?: string;
};
declare const PopoverRoot: PopoverRootComponent;
type PopoverTriggerProps = {
    children: React.ReactNode;
    asChild?: boolean;
} & Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'children'>;
type PopoverTriggerComponent = React.ForwardRefExoticComponent<Readonly<PopoverTriggerProps> & React.RefAttributes<HTMLElement>>;
declare const PopoverTrigger: PopoverTriggerComponent;
type PopoverContentProps = React.HTMLAttributes<HTMLDivElement>;
type PopoverContentComponent = React.ForwardRefExoticComponent<Readonly<PopoverContentProps> & React.RefAttributes<HTMLDivElement>>;
declare const PopoverContent: PopoverContentComponent;
type PopoverComponent = typeof PopoverRoot & {
    Trigger: typeof PopoverTrigger;
    Content: typeof PopoverContent;
};
declare const Popover: PopoverComponent;

type ProgressSize = 'sm' | 'md' | 'lg';
type ProgressProps = Omit<React.HTMLAttributes<HTMLDivElement>, 'children' | 'className' | 'style'> & {
    value?: number;
    max?: number;
    indeterminate?: boolean;
    label?: string;
    showValue?: boolean;
    size?: ProgressSize;
    className?: string;
    style?: React.CSSProperties;
    barClassName?: string;
};
type ProgressComponent = React.ForwardRefExoticComponent<Readonly<ProgressProps> & React.RefAttributes<HTMLDivElement>>;
declare const Progress: ProgressComponent;

type RadioGroupOrientation = 'vertical' | 'horizontal';
type RadioOption = {
    value: string;
    label: string;
    description?: string;
    disabled?: boolean;
};
type RadioGroupProps = Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange' | 'defaultValue' | 'className' | 'style' | 'children'> & {
    label: string;
    options: ReadonlyArray<RadioOption>;
    value?: string;
    defaultValue?: string;
    onChange?: React.ChangeEventHandler<HTMLInputElement>;
    hideLabel?: boolean;
    helperText?: string;
    error?: string;
    disabled?: boolean;
    required?: boolean;
    orientation?: RadioGroupOrientation;
    name?: string;
    id?: string;
    className?: string;
    style?: React.CSSProperties;
};
type RadioGroupComponent = React.ForwardRefExoticComponent<Readonly<RadioGroupProps> & React.RefAttributes<HTMLDivElement>>;
declare const RadioGroup: RadioGroupComponent;

type SelectSize = 'sm' | 'md' | 'lg';
type SelectProps = Omit<React.SelectHTMLAttributes<HTMLSelectElement>, 'size' | 'className' | 'style'> & {
    label: string;
    hideLabel?: boolean;
    error?: string;
    helperText?: string;
    placeholder?: string;
    size?: SelectSize;
    className?: string;
    style?: React.CSSProperties;
};
type SelectComponent = React.ForwardRefExoticComponent<Readonly<SelectProps> & React.RefAttributes<HTMLSelectElement>>;
declare const Select: SelectComponent;

type SkeletonShape = 'rectangle' | 'circle';
type SkeletonProps = {
    width?: string | number;
    height?: string | number;
    shape?: SkeletonShape;
    className?: string;
    style?: React.CSSProperties;
};
type SkeletonComponent = React.ForwardRefExoticComponent<Readonly<SkeletonProps> & React.RefAttributes<HTMLSpanElement>>;
declare const Skeleton: SkeletonComponent;

type SpinnerSize = 'sm' | 'md' | 'lg';
type SpinnerProps = {
    size?: SpinnerSize | number;
    label?: string;
    className?: string;
    style?: React.CSSProperties;
};
type SpinnerComponent = React.ForwardRefExoticComponent<Readonly<SpinnerProps> & React.RefAttributes<HTMLOutputElement>>;
declare const Spinner: SpinnerComponent;

type StackProps<E extends BoxElement = 'div'> = Omit<FlexProps<E>, 'direction'> & {
    direction?: 'vertical' | 'horizontal';
};
type StackComponent = (<E extends BoxElement = 'div'>(props: Readonly<StackProps<E>> & {
    ref?: PolymorphicRef<E>;
}) => React.ReactElement | null) & {
    displayName?: string;
};
declare const Stack: StackComponent;

type SwitchSize = 'sm' | 'md' | 'lg';
type SwitchProps = Omit<React.InputHTMLAttributes<HTMLInputElement>, 'type' | 'size' | 'className' | 'style'> & {
    label: string;
    hideLabel?: boolean;
    size?: SwitchSize;
    className?: string;
    style?: React.CSSProperties;
};
type SwitchComponent = React.ForwardRefExoticComponent<Readonly<SwitchProps> & React.RefAttributes<HTMLInputElement>>;
declare const Switch: SwitchComponent;

type TableProps = React.TableHTMLAttributes<HTMLTableElement> & {
    containerClassName?: string;
    containerStyle?: React.CSSProperties;
};
type TableHeaderProps = React.HTMLAttributes<HTMLTableSectionElement>;
type TableBodyProps = React.HTMLAttributes<HTMLTableSectionElement>;
type TableFooterProps = React.HTMLAttributes<HTMLTableSectionElement>;
type TableRowProps = React.HTMLAttributes<HTMLTableRowElement>;
type TableHeadProps = React.ThHTMLAttributes<HTMLTableCellElement>;
type TableCellProps = React.TdHTMLAttributes<HTMLTableCellElement>;
type TableCaptionProps = React.HTMLAttributes<HTMLTableCaptionElement>;
type TableRootComponent = React.ForwardRefExoticComponent<Readonly<TableProps> & React.RefAttributes<HTMLTableElement>>;
declare const TableRoot: TableRootComponent;
type TableHeaderComponent = React.ForwardRefExoticComponent<Readonly<TableHeaderProps> & React.RefAttributes<HTMLTableSectionElement>>;
declare const TableHeader: TableHeaderComponent;
type TableBodyComponent = React.ForwardRefExoticComponent<Readonly<TableBodyProps> & React.RefAttributes<HTMLTableSectionElement>>;
declare const TableBody: TableBodyComponent;
type TableFooterComponent = React.ForwardRefExoticComponent<Readonly<TableFooterProps> & React.RefAttributes<HTMLTableSectionElement>>;
declare const TableFooter: TableFooterComponent;
type TableRowComponent = React.ForwardRefExoticComponent<Readonly<TableRowProps> & React.RefAttributes<HTMLTableRowElement>>;
declare const TableRow: TableRowComponent;
type TableHeadComponent = React.ForwardRefExoticComponent<Readonly<TableHeadProps> & React.RefAttributes<HTMLTableCellElement>>;
declare const TableHead: TableHeadComponent;
type TableCellComponent = React.ForwardRefExoticComponent<Readonly<TableCellProps> & React.RefAttributes<HTMLTableCellElement>>;
declare const TableCell: TableCellComponent;
type TableCaptionComponent = React.ForwardRefExoticComponent<Readonly<TableCaptionProps> & React.RefAttributes<HTMLTableCaptionElement>>;
declare const TableCaption: TableCaptionComponent;
type TableComponent = typeof TableRoot & {
    Header: typeof TableHeader;
    Body: typeof TableBody;
    Footer: typeof TableFooter;
    Row: typeof TableRow;
    Head: typeof TableHead;
    Cell: typeof TableCell;
    Caption: typeof TableCaption;
};
declare const Table: TableComponent;

type TabsProps = React.HTMLAttributes<HTMLDivElement> & {
    value?: string;
    defaultValue?: string;
    onValueChange?: (value: string) => void;
};
type TabsRootComponent = React.ForwardRefExoticComponent<Readonly<TabsProps> & React.RefAttributes<HTMLDivElement>>;
declare const TabsRoot: TabsRootComponent;
type TabsListProps = React.HTMLAttributes<HTMLDivElement>;
type TabsListComponent = React.ForwardRefExoticComponent<Readonly<TabsListProps> & React.RefAttributes<HTMLDivElement>>;
declare const TabsList: TabsListComponent;
type TabsTriggerProps = React.ButtonHTMLAttributes<HTMLButtonElement> & {
    value: string;
};
type TabsTriggerComponent = React.ForwardRefExoticComponent<Readonly<TabsTriggerProps> & React.RefAttributes<HTMLButtonElement>>;
declare const TabsTrigger: TabsTriggerComponent;
type TabsContentProps = React.HTMLAttributes<HTMLDivElement> & {
    value: string;
};
type TabsContentComponent = React.ForwardRefExoticComponent<Readonly<TabsContentProps> & React.RefAttributes<HTMLDivElement>>;
declare const TabsContent: TabsContentComponent;
type TabsComponent = typeof TabsRoot & {
    List: typeof TabsList;
    Trigger: typeof TabsTrigger;
    Content: typeof TabsContent;
};
declare const Tabs: TabsComponent;

type TextareaResize = 'none' | 'vertical' | 'horizontal' | 'both';
type TextareaProps = Omit<React.TextareaHTMLAttributes<HTMLTextAreaElement>, 'className' | 'style'> & {
    label: string;
    hideLabel?: boolean;
    error?: string;
    helperText?: string;
    resize?: TextareaResize;
    className?: string;
    style?: React.CSSProperties;
};
type TextareaComponent = React.ForwardRefExoticComponent<Readonly<TextareaProps> & React.RefAttributes<HTMLTextAreaElement>>;
declare const Textarea: TextareaComponent;

type TextInputProps = Omit<React.InputHTMLAttributes<HTMLInputElement>, 'type' | 'className' | 'style'> & {
    label: string;
    hideLabel?: boolean;
    error?: string;
    helperText?: string;
    type?: 'text' | 'email' | 'password' | 'search' | 'tel' | 'url';
    className?: string;
    style?: React.CSSProperties;
};
type TextInputComponent = React.ForwardRefExoticComponent<Readonly<TextInputProps> & React.RefAttributes<HTMLInputElement>>;
declare const TextInput: TextInputComponent;

type FreyTheme = 'light' | 'dark' | 'system';
type ThemeProviderProps = {
    children: React.ReactNode;
    theme?: FreyTheme;
    highContrast?: boolean;
    id?: string;
    className?: string;
    style?: React.CSSProperties;
};
type ThemeContextValue = {
    resolvedTheme: 'light' | 'dark';
    highContrast: boolean;
};
declare function useTheme(): ThemeContextValue;
declare function ThemeProvider({ children, theme, highContrast, id, className, style, }: Readonly<ThemeProviderProps>): React.JSX.Element;

type ToastVariant = 'info' | 'success' | 'warning' | 'error';
type ToastPlacement = 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left';
type ToastAction = {
    label: string;
    onClick: () => void;
};
type ToastOptions = {
    id?: string;
    title?: string;
    description: string;
    variant?: ToastVariant;
    duration?: number;
    action?: ToastAction;
};
type ToastProviderProps = {
    children: React.ReactNode;
    placement?: ToastPlacement;
    limit?: number;
    className?: string;
    style?: React.CSSProperties;
};
type ToastContextValue = {
    toast: (options: ToastOptions) => string;
    dismiss: (id: string) => void;
    dismissAll: () => void;
};
declare function ToastProvider({ children, placement, limit, className, style, }: Readonly<ToastProviderProps>): React.JSX.Element;
declare function useToast(): ToastContextValue;

type TooltipPlacement = 'top' | 'right' | 'bottom' | 'left';
type TooltipProps = {
    children: React.ReactNode;
    asChild?: boolean;
    content: React.ReactNode;
    open?: boolean;
    defaultOpen?: boolean;
    onOpenChange?: (open: boolean) => void;
    placement?: TooltipPlacement;
    offset?: number;
    delay?: number;
    id?: string;
    className?: string;
    style?: React.CSSProperties;
};
declare function Tooltip({ children, asChild, content, open, defaultOpen, onOpenChange, placement, offset, delay, id, className, style, }: Readonly<TooltipProps>): React.JSX.Element;

export { Accordion, Alert, Avatar, Badge, Box, Breadcrumbs, Button, Card, CheckIcon, Checkbox, ChevronDownIcon, Chip, CircleCheckIcon, CircleInfoIcon, CircleXIcon, CloseIcon, Combobox, CommandPalette, Dialog, Drawer, DropdownMenu, Field, Flex, Grid, Link, MinusIcon, Pagination, Popover, Progress, RadioGroup, Select, Skeleton, Spinner, Stack, Switch, Table, Tabs, TextInput, Textarea, ThemeProvider, ToastProvider, Tooltip, TriangleAlertIcon, useTheme, useToast };
export type { AccordionContentProps, AccordionItemProps, AccordionProps, AccordionTriggerProps, AccordionType, AlertProps, AlertVariant, AvatarProps, AvatarSize, AvatarStatus, BadgeProps, BadgeSize, BadgeTone, BadgeVariant, BoxProps, BreadcrumbsCurrentProps, BreadcrumbsItemProps, BreadcrumbsLinkProps, BreadcrumbsListProps, BreadcrumbsProps, ButtonProps, ButtonSize, ButtonVariant, CardContentProps, CardFooterProps, CardHeaderProps, CardProps, CardTitleProps, CheckboxProps, CheckboxSize, ChipElement, ChipProps, ColorToken, ComboboxOption, ComboboxProps, ComboboxSize, CommandPaletteContentProps, CommandPaletteEmptyProps, CommandPaletteGroupProps, CommandPaletteInputProps, CommandPaletteItemProps, CommandPaletteListProps, CommandPaletteProps, CommandPaletteShortcutProps, CommandPaletteTriggerProps, DialogBodyProps, DialogContentProps, DialogDescriptionProps, DialogFooterProps, DialogHeaderProps, DialogProps, DialogTitleProps, DialogTriggerProps, DrawerBodyProps, DrawerContentProps, DrawerDescriptionProps, DrawerFooterProps, DrawerHeaderProps, DrawerPlacement, DrawerProps, DrawerTitleProps, DrawerTriggerProps, DropdownMenuContentProps, DropdownMenuItemProps, DropdownMenuPlacement, DropdownMenuProps, DropdownMenuTriggerProps, FieldProps, FieldRenderProps, FlexProps, FreyTheme, GridProps, IconProps, IconSizeToken, IconStrokeToken, LinkColor, LinkProps, LinkUnderline, PaginationProps, PopoverContentProps, PopoverPlacement, PopoverProps, PopoverTriggerProps, ProgressProps, ProgressSize, RadioGroupOrientation, RadioGroupProps, RadioOption, RadiusToken, SelectProps, SelectSize, SkeletonProps, SkeletonShape, SpaceToken, SpinnerProps, SpinnerSize, StackProps, SwitchProps, SwitchSize, TableBodyProps, TableCaptionProps, TableCellProps, TableFooterProps, TableHeadProps, TableHeaderProps, TableProps, TableRowProps, TabsContentProps, TabsListProps, TabsProps, TabsTriggerProps, TextInputProps, TextareaProps, TextareaResize, ThemeContextValue, ThemeProviderProps, ToastAction, ToastOptions, ToastPlacement, ToastProviderProps, ToastVariant, TooltipPlacement, TooltipProps, Variant };