@maxio-com/react-ui-components 9.8.1 → 9.9.0

package/typings/index.d.ts

@@ -0,0 +1,792 @@
+import React$1, { ReactNode, HTMLAttributes, LiHTMLAttributes, AnchorHTMLAttributes, RefObject, FC, ElementType, InputHTMLAttributes } from 'react';
+import { RowData, Row, Table, ExpandedState, RowSelectionState, SortingState, TableOptions } from '@tanstack/react-table';
+export { createColumnHelper } from '@tanstack/react-table';
+import * as _floating_ui_react_dom_interactions from '@floating-ui/react-dom-interactions';
+import { MotionProps } from 'framer-motion';
+import { PopoverProps as PopoverProps$1, ListBoxProps as ListBoxProps$1, ListBoxItemProps as ListBoxItemProps$1, ListBoxSectionProps as ListBoxSectionProps$1, HeaderProps } from 'react-aria-components';
+export { DialogTrigger, Pressable } from 'react-aria-components';
+import { ToastState, ToastQueue as ToastQueue$1 } from '@react-stately/toast';
+import { AriaCheckboxGroupProps, AriaRadioGroupProps, AriaToggleButtonProps } from 'react-aria';
+
+declare const ICONS: readonly ["address-card", "arrow-down", "arrow-down-left", "arrow-down-left-long", "arrow-down-long", "arrow-down-right", "arrow-down-right-long", "arrow-down-up", "arrow-left", "arrow-left-long", "arrow-left-right", "arrow-right", "arrow-right-long", "arrow-turn-down-right", "arrow-up", "arrow-up-left", "arrow-up-left-long", "arrow-up-long", "arrow-up-right", "arrow-up-right-long", "bank", "bar-chart", "briefcase", "building", "business-intelligence", "calendar", "caret-down", "caret-left", "caret-right", "caret-up", "chat", "check", "check-box", "check-box-checked", "check-box-checked-fill", "check-box-indeterminate-fill", "check-circle", "check-circle-fill", "chevron-down", "chevron-left", "chevron-right", "chevron-up", "chevron-up-down", "circle", "circle-half-stroke-small", "circle-small-dash", "circle-small-fill", "circle-small-stroke", "clipboard", "cog", "copy-file", "credit-card", "cross", "cross-circle", "cross-circle-fill", "dashboard", "diamond-small-fill", "document", "document-blank", "dollar", "dot-circle-fill", "dot-fill", "error", "error-fill", "error-small-fill", "graph", "home", "info-circle", "info-circle-fill", "line-vertical", "list", "login", "logout", "megaphone", "menu", "menu-chevron-left", "menu-chevron-right", "notification", "notification-unread", "pen", "plus", "plus-circle", "plus-circle-fill", "question-circle", "question-circle-fill", "recently-viewed", "search", "square-small-fill", "trash", "triangle-small-fill", "user", "warning-circle", "warning-circle-fill", "dropbox", "hubspot", "sage", "oracle", "quotapath", "avalara", "pipedrive", "quickbooks", "salesforce", "xero"];
+
+type IconVariant = (typeof ICONS)[number] | string;
+type IconProps = {
+    className?: string;
+    size?: 'xs' | 'md' | 'lg';
+    variant: IconVariant;
+    color?: string;
+};
+
+declare const Icon: ({ variant, color, className, size }: IconProps) => React$1.JSX.Element;
+//# sourceMappingURL=Icon.d.ts.map
+
+interface DividerListItem {
+    id: string | number;
+    type: 'divider';
+}
+interface ListItem {
+    type?: 'default';
+    id: string | number;
+    label: string;
+    description?: string;
+    leadingIconName?: IconVariant;
+    leadingIconClassName?: string;
+    trailingIconName?: IconVariant;
+    link: React.AnchorHTMLAttributes<HTMLAnchorElement>;
+}
+interface ActionItemProps extends React.HTMLAttributes<HTMLAnchorElement | HTMLDivElement> {
+    item: ActionListItem;
+    isSelected: boolean;
+    truncateLabel?: boolean;
+    small?: boolean;
+}
+type ActionListItem = ListItem | DividerListItem;
+interface ActionListProps extends React.HTMLAttributes<HTMLDivElement> {
+    items: ActionListItem[];
+    isShadowed?: boolean;
+    itemProps?: Omit<ActionItemProps, 'item' | 'isSelected'>;
+    truncateLabels?: boolean;
+    small?: boolean;
+}
+
+declare const ActionList: ({ items, isShadowed, itemProps, className, truncateLabels, small, ...props }: ActionListProps) => React$1.JSX.Element | null;
+//# sourceMappingURL=ActionList.d.ts.map
+
+type Sentiment$3 = 'info' | 'success' | 'warning' | 'danger';
+type AlertProps = {
+    title?: string;
+    children?: string;
+    onDismiss?: () => void;
+    linkText?: string;
+    linkExternal?: boolean;
+    href?: string;
+    sentiment?: Sentiment$3;
+    className?: string;
+    display?: 'inline' | 'block';
+};
+
+declare const Alert: ({ children, title, linkText, linkExternal, href, display, sentiment, onDismiss, className, }: AlertProps) => React$1.JSX.Element | null;
+//# sourceMappingURL=Alert.d.ts.map
+
+interface MenuProps {
+    children: ReactNode | (({ isOpen, onClose, }: {
+        isOpen: boolean;
+        onClose: () => void;
+    }) => ReactNode);
+}
+declare const Menu: ({ children }: MenuProps) => React$1.JSX.Element;
+
+interface MenuListProps {
+    items: ActionListItem[];
+    alignItemsEnd?: boolean;
+}
+declare const MenuList: ({ items, alignItemsEnd }: MenuListProps) => React$1.JSX.Element;
+//# sourceMappingURL=MenuList.d.ts.map
+
+type ButtonVariant = 'primary' | 'secondary' | 'tertiary' | 'ghost' | 'danger' | 'skeleton';
+type ButtonSize$1 = 'sm' | 'md' | 'lg' | 'xl';
+interface CommonButtonProps {
+    variant?: ButtonVariant;
+    size?: ButtonSize$1;
+    fullWidth?: boolean;
+    leadingElement?: React.ReactNode;
+    trailingElement?: React.ReactNode;
+    icon?: React.ReactNode;
+}
+interface InternalButtonProps extends CommonButtonProps, Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'value'> {
+    disabled?: boolean;
+    loading?: boolean;
+    href?: never;
+    value?: string;
+}
+interface InternalLinkProps extends CommonButtonProps, React.HTMLAttributes<HTMLAnchorElement> {
+    href?: string;
+}
+type ButtonProps = InternalButtonProps | InternalLinkProps;
+
+type MenuButtonProps = Omit<ButtonProps, 'onClick' | 'children' | 'disabled' | 'loading' | 'icon'> & {
+    children?: React.ReactNode;
+    iconName?: IconVariant | null;
+};
+
+declare const MenuButton: ({ children, iconName, "aria-label": ariaLabel, size, variant, }: MenuButtonProps) => React$1.JSX.Element;
+//# sourceMappingURL=MenuButton.d.ts.map
+
+type AvatarProps = {
+    className?: string;
+    src: string;
+    alt?: string;
+};
+
+declare const Avatar: ({ className, src, alt }: AvatarProps) => React$1.JSX.Element;
+//# sourceMappingURL=Avatar.d.ts.map
+
+type Sentiment$2 = 'info' | 'success' | 'warning' | 'danger';
+type BannerProps = {
+    title?: string;
+    children: string;
+    onDismiss?: () => void;
+    linkText?: string;
+    linkExternal?: boolean;
+    href?: string;
+    sentiment?: Sentiment$2;
+    className?: string;
+    display?: 'inline' | 'block';
+};
+
+declare const Banner: ({ children, title, linkText, linkExternal, href, display, sentiment, onDismiss, className, }: BannerProps) => React$1.JSX.Element | null;
+//# sourceMappingURL=Banner.d.ts.map
+
+type BreadcrumbsProps = HTMLAttributes<HTMLElement>;
+type BreadcrumbsItemProps = {
+    href?: string;
+} & LiHTMLAttributes<HTMLLIElement>;
+
+declare const Breadcrumbs: React$1.FC<BreadcrumbsProps>;
+//# sourceMappingURL=Breadcrumbs.d.ts.map
+
+declare const BreadcrumbsItem: React$1.FC<BreadcrumbsItemProps>;
+//# sourceMappingURL=BreadcrumbsItem.d.ts.map
+
+declare const Button: (props: ButtonProps) => React$1.JSX.Element;
+//# sourceMappingURL=Button.d.ts.map
+
+type ButtonSize = 'sm' | 'md' | 'lg';
+type IconButtonProps = (Omit<InternalButtonProps, 'fullWidth' | 'children'> | Omit<InternalLinkProps, 'fullWidth' | 'children'>) & {
+    'aria-label': string;
+    size?: ButtonSize;
+};
+
+declare const IconButton: ({ "aria-label": ariaLabel, className, ...props }: IconButtonProps) => React$1.JSX.Element;
+//# sourceMappingURL=IconButton.d.ts.map
+
+type TableSize = 'sm' | 'md' | 'lg';
+type ColumnAlign = 'left' | 'right';
+type RequiredTableOptions<TData extends RowData> = Pick<TableOptions<TData>, 'data' | 'columns'>;
+type OptionalTableOptions<TData extends RowData> = Partial<Omit<TableOptions<TData>, 'getCoreRowModel' | 'enableExpanding'>>;
+type DataTableProps<TData extends RowData = unknown> = {
+    size?: TableSize;
+    pattern?: boolean;
+    align?: ColumnAlign;
+    enableExpanding?: boolean | 'rowsOnly';
+    SubRowComponent?: (row: Row<TData>) => React.ReactNode;
+    isLoading?: boolean;
+    actions?: (row: Row<TData>, table: Table<TData>) => React.ReactNode;
+    onExpand?: (expanded: ExpandedState) => void;
+    onSelect?: (selected: RowSelectionState) => void;
+    onSort?: (selected: SortingState) => void;
+} & RequiredTableOptions<TData> & OptionalTableOptions<TData>;
+declare module '@tanstack/react-table' {
+    interface ColumnMeta<TData extends RowData, TValue> {
+        align?: ColumnAlign;
+        width?: string;
+        controls?: boolean;
+        actions?: boolean;
+    }
+}
+
+declare const DataTable: <TData extends RowData>({ pattern, size, SubRowComponent, onExpand, onSelect, onSort, enableSorting, enableRowSelection, enableExpanding, columns: originalColumns, actions, ...props }: DataTableProps<TData>) => React$1.JSX.Element;
+//# sourceMappingURL=DataTable.d.ts.map
+
+type Variant = 'primary' | 'secondary' | 'tertiary' | 'high-contrast' | 'inverse';
+type Size = 'xs' | 'sm' | 'md' | 'lg';
+interface LinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
+    className?: string;
+    children: ReactNode;
+    size?: Size;
+    disabled?: boolean;
+    icon?: IconVariant;
+    external?: boolean;
+    variant?: Variant;
+    underline?: boolean;
+}
+
+declare const Link: React$1.FC<LinkProps>;
+//# sourceMappingURL=Link.d.ts.map
+
+type LoadingSpinnerSize = 'sm' | 'md' | 'lg' | 'xl';
+type LoadingSpinnerProps = {
+    size?: LoadingSpinnerSize;
+    white?: boolean;
+    className?: string;
+};
+
+declare const LoadingSpinner: ({ size, white, className, }: LoadingSpinnerProps) => React$1.JSX.Element;
+//# sourceMappingURL=LoadingSpinner.d.ts.map
+
+type Alignment = 'start' | 'end';
+type Side = 'top' | 'right' | 'bottom' | 'left';
+type AlignedPlacement = `${Side}-${Alignment}`;
+type Placement = Side | AlignedPlacement;
+type Interactions = 'click' | 'hover' | 'focus' | 'dismiss';
+type OverlayAriaRole = 'tooltip' | 'dialog' | 'alertdialog' | 'menu' | 'listbox' | 'grid' | 'tree';
+
+type OverlayTriggerSettings = {
+    placement?: Placement;
+    isInitiallyActive?: boolean;
+    interactions?: Interactions[];
+    floatingElementOffset?: number;
+    role: OverlayAriaRole;
+    isActive?: boolean;
+    onOverlayUpdate: (isActive: boolean) => void;
+    autoHideMs?: number;
+};
+declare const useOverlayTrigger: ({ placement, isActive, interactions, floatingElementOffset, onOverlayUpdate, autoHideMs, }: OverlayTriggerSettings) => {
+    isActive: boolean;
+    refs: {
+        floating: (node: HTMLElement | null) => void;
+        reference: (node: _floating_ui_react_dom_interactions.ReferenceType | null) => void;
+    };
+    floatingElementCSSPosition: {
+        position: _floating_ui_react_dom_interactions.Strategy;
+        top: number;
+        left: number;
+    };
+    getReferenceProps: (userProps?: React.HTMLProps<Element> | undefined) => Record<string, unknown>;
+    getFloatingProps: (userProps?: React.HTMLProps<HTMLElement> | undefined) => Record<string, unknown>;
+};
+
+declare function useHover<T extends HTMLElement = HTMLElement>(ref: RefObject<T | null>, mouseLeaveDelay?: number): boolean;
+
+declare function useWindowSize(debounce?: number): {
+    windowWitdh: number;
+    windowHeight: number;
+};
+
+type OverlayTriggerProps = {
+    children: React$1.ReactNode;
+    placement?: Placement;
+    usePortal?: boolean;
+    interactions?: Interactions[];
+    renderOverlay: () => React$1.ReactNode;
+    role?: OverlayAriaRole;
+    floatingElementOffset?: number;
+    isActive?: boolean;
+    onOverlayUpdate: (isActive: boolean) => void;
+    motionSettings?: MotionProps;
+    autoHideMs?: number;
+    className?: string;
+};
+declare const OverlayTrigger: FC<OverlayTriggerProps>;
+
+type PageInfo = {
+    currentPage: number;
+    itemsPerPage: number;
+};
+type PaginationProps = {
+    totalItems?: number;
+    currentPage?: number;
+    itemsPerPage?: number;
+    pageSizeOptions: number[];
+    size?: 'sm' | 'md' | 'lg';
+    onChange?: (pageInfo: PageInfo) => void;
+    manualPageInput?: boolean;
+};
+
+declare const Pagination: ({ size, onChange, totalItems, itemsPerPage: itemsPerPageProp, currentPage: currentPageProp, pageSizeOptions, manualPageInput, }: PaginationProps) => React$1.JSX.Element;
+//# sourceMappingURL=Pagination.d.ts.map
+
+interface PopoverProps extends Omit<PopoverProps$1, 'children'> {
+    children: ReactNode;
+    hideArrow?: boolean;
+}
+
+declare const Popover: ({ className, hideArrow, children, ...props }: PopoverProps) => React$1.JSX.Element;
+//# sourceMappingURL=Popover.d.ts.map
+
+interface ProgressBarProps {
+    label: string;
+    helperText?: string;
+    size?: 'md' | 'lg';
+    status?: 'success' | 'error';
+    variant?: 'default' | 'inline' | 'indent';
+    value?: number;
+    maxValue?: number;
+}
+declare const ProgressBar: ({ label, helperText, size, variant, status, value, maxValue, }: ProgressBarProps) => React$1.JSX.Element;
+
+interface SingleSection {
+    href?: string;
+    icon: IconVariant | null;
+    name: string;
+    key: string;
+    isCurrent?: boolean;
+    type?: 'regular';
+}
+interface SingleSectionWithItems extends SingleSection {
+    isOpen?: boolean;
+    items?: SingleSection[];
+}
+type SectionComponent = React.FC<{
+    section: SingleSectionWithItems;
+}>;
+interface Section extends SingleSectionWithItems {
+    Component?: SectionComponent;
+}
+interface SectionHeading {
+    title: string;
+    type?: 'heading';
+}
+type SectionGroup = (Section | SectionHeading)[];
+interface SideNavProviderProps {
+    children: ReactNode;
+    withIcons?: boolean;
+    shouldToggleSidebar?: boolean;
+    sections: SectionGroup[];
+    collapseBreakpoint?: number;
+    topDropdownItems: SideNavTopDropdown;
+    isOpen?: boolean;
+    onChange?: (isOpen: boolean) => void;
+}
+interface SideNavTopDropdown {
+    mainItem: SideNavTopDropdownItem;
+    otherItems: SideNavTopDropdownItem[];
+    actions: SideNavTopDropdownItem[];
+}
+interface SideNavTopDropdownItem extends AnchorHTMLAttributes<HTMLAnchorElement> {
+    id: string;
+    title: string;
+    icon: IconVariant;
+    iconClass?: string;
+    url: string;
+    rel?: string;
+}
+
+type SideNavWrapperProps = Omit<SideNavProviderProps, 'children'>;
+declare const SideNavWrapper: ({ withIcons, shouldToggleSidebar, topDropdownItems, sections, collapseBreakpoint, isOpen, onChange, }: SideNavWrapperProps) => React$1.JSX.Element;
+
+type CommonTabProps = React.HTMLAttributes<HTMLDivElement> & {
+    disabled?: boolean;
+    value?: number;
+    isCurrent?: boolean;
+};
+type IconTab = {
+    type: 'icon';
+    icon: ReactNode;
+};
+type DefaultTab = {
+    type?: 'default';
+    children: ReactNode;
+    rightIcon?: ReactNode;
+};
+type TabProps = CommonTabProps & (DefaultTab | IconTab);
+
+declare const Tab: ({ disabled, value, isCurrent, ...props }: TabProps) => React$1.JSX.Element;
+//# sourceMappingURL=Tab.d.ts.map
+
+type TabsVariant = 'line' | 'contained';
+interface TabsContext {
+    variant: TabsVariant;
+    withDivider: boolean;
+    onChange: (idx: number | ((prevIdx: number) => number)) => void;
+    currentIndex: number;
+}
+type TabsProviderProps = Omit<Partial<TabsContext>, 'currentIndex'> & {
+    children: ReactNode;
+    defaultIndex?: number;
+    index?: number;
+};
+
+type TabsProps = TabsProviderProps;
+declare const Tabs: ({ children, variant, withDivider, defaultIndex, index, onChange, }: TabsProps) => React$1.JSX.Element;
+//# sourceMappingURL=Tabs.d.ts.map
+
+interface TabPanelProps extends React$1.HtmlHTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+    value?: number;
+}
+declare const TabPanel: ({ children, value, ...props }: TabPanelProps) => React$1.JSX.Element;
+
+interface TabPanelsProps {
+    children: React$1.ReactNode;
+}
+declare const TabPanels: ({ children }: TabPanelsProps) => React$1.JSX.Element;
+//# sourceMappingURL=TabPanels.d.ts.map
+
+interface TabListProps extends React$1.HtmlHTMLAttributes<HTMLDivElement> {
+    ariaLabel: string;
+    children: ReactNode;
+}
+declare const TabList: ({ children, className, ariaLabel, ...props }: TabListProps) => React$1.JSX.Element;
+//# sourceMappingURL=TabList.d.ts.map
+
+type TagSize = 'sm';
+type TagKind = 'primary' | 'secondary' | 'tertiary';
+type TagSentiment = 'info' | 'success' | 'warning' | 'danger' | 'highlight';
+type TagProps = {
+    children: React.ReactNode;
+    leadingIcon?: IconVariant;
+    trailingIcon?: IconVariant;
+    size?: TagSize;
+    sentiment?: TagSentiment;
+    kind?: TagKind;
+};
+
+declare const Tag: ({ children, size, sentiment, kind, leadingIcon, trailingIcon, }: TagProps) => React$1.JSX.Element;
+//# sourceMappingURL=Tag.d.ts.map
+
+type CardVariant = 'primary' | 'secondary';
+type CardProps = {
+    variant?: CardVariant;
+} & React.HTMLAttributes<HTMLDivElement>;
+
+declare const CardHeader: {
+    ({ children, className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): React$1.JSX.Element;
+    displayName: string;
+};
+declare const CardBody: {
+    ({ children, className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): React$1.JSX.Element;
+    displayName: string;
+};
+declare const CardFooter: {
+    ({ children, className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): React$1.JSX.Element;
+    displayName: string;
+};
+declare const CardRoot: {
+    ({ children, className, variant, ...props }: CardProps): React$1.JSX.Element;
+    displayName: string;
+};
+type CardComponent = typeof CardRoot & {
+    Header: typeof CardHeader;
+    Body: typeof CardBody;
+    Footer: typeof CardFooter;
+};
+declare const Card: CardComponent;
+//# sourceMappingURL=Card.d.ts.map
+
+type TileProps = {
+    disabled?: boolean;
+    href?: string;
+    target?: 'string';
+    onClick?: () => void;
+} & React$1.HTMLAttributes<HTMLDivElement>;
+declare const Tile: ({ children, className, href, onClick, target, disabled, }: TileProps) => React$1.JSX.Element;
+//# sourceMappingURL=Tile.d.ts.map
+
+type LogoProps = {
+    className?: string;
+    variant?: 'lockup' | 'mark';
+    alt?: string;
+    size?: 'sm' | 'md' | 'lg' | number;
+};
+
+declare const Logo: (props: LogoProps) => React$1.JSX.Element;
+//# sourceMappingURL=Logo.d.ts.map
+
+type Sentiment$1 = 'info' | 'success' | 'warning' | 'danger';
+interface ToastContent extends Omit<LinkProps, 'children'> {
+    title?: string;
+    message?: string | ReactNode;
+    link?: {
+        text: string;
+        href: string;
+    };
+    sentiment?: Sentiment$1;
+    closable?: boolean;
+}
+
+type ToastProviderProps = {
+    children: (state: ToastState<ToastContent>) => any;
+    className?: string;
+    maxVisibleToasts?: number;
+};
+
+declare const ToastProvider: ({ children, ...props }: ToastProviderProps) => React$1.JSX.Element;
+//# sourceMappingURL=ToastProvider.d.ts.map
+
+type GlobalToastProviderProps = {
+    children: React.ReactNode;
+    className?: string;
+    toastQueue: ToastQueue;
+};
+interface ToastContextValue {
+    addToast: (toast: Omit<ToastContent, 'id'>) => string;
+    removeToast: (id: string) => void;
+    removeAllToasts: () => void;
+    state: ToastState<ToastContent>;
+}
+
+declare const GlobalToastProvider: ({ children, toastQueue, ...props }: GlobalToastProviderProps) => React$1.JSX.Element;
+declare const useToast: () => ToastContextValue;
+declare class ToastQueue extends ToastQueue$1<ToastContent> {
+}
+
+type ToggleProps = {
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onChange?: (value: boolean, event?: React$1.ChangeEvent<HTMLInputElement> | React$1.KeyboardEvent<HTMLInputElement>) => void;
+    disabled?: boolean;
+    name?: string;
+    valueDescription?: string;
+    valueDescriptionPosition?: 'left' | 'right';
+    className?: string;
+    id?: string;
+    'aria-label'?: string;
+};
+declare const Toggle: ({ defaultChecked, checked, onChange, disabled, valueDescription, valueDescriptionPosition, className, name, id, ...props }: ToggleProps) => React$1.JSX.Element;
+
+type ArrowPosition = 'top' | 'top-left' | 'top-right' | 'bottom' | 'bottom-left' | 'bottom-right' | 'left' | 'left-top' | 'left-bottom' | 'right' | 'right-top' | 'right-bottom';
+
+type TooltipProps = {
+    children: React$1.ReactNode;
+    size?: 'regular' | 'small';
+    arrowPosition?: ArrowPosition;
+    maxWidth?: number | 'none';
+};
+declare const Tooltip: FC<TooltipProps>;
+
+type TooltipTriggerProps = {
+    children: React$1.ReactNode;
+    isVisible?: boolean;
+    onVisibilityUpdate?: (isVisible: boolean) => void;
+    renderContent: () => React$1.ReactNode;
+    floatingElementOffset?: number;
+} & Pick<OverlayTriggerProps, 'placement' | 'interactions' | 'usePortal' | 'autoHideMs' | 'className'> & Pick<TooltipProps, 'size' | 'maxWidth'>;
+declare const TooltipTrigger: FC<TooltipTriggerProps>;
+
+type TopBarProps = {
+    actions: React$1.ReactNode;
+    children?: React$1.ReactNode;
+    sideNavIsClosed?: boolean;
+    openSideNav?: () => void;
+};
+
+declare const TopBar: ({ children, actions, sideNavIsClosed, openSideNav, }: TopBarProps) => React$1.JSX.Element;
+
+type BaseTypographyProps = {
+    className?: string;
+    children: ReactNode;
+};
+
+type BodyProps = BaseTypographyProps & {
+    as?: ElementType;
+    size?: 'xs' | 'sm' | 'md' | 'lg';
+    compact?: boolean;
+};
+declare const Body: ({ as, children, compact, size, className, ...rest }: BodyProps) => React$1.JSX.Element;
+
+type HeadingProps = BaseTypographyProps & {
+    size?: 'sm' | 'md' | 'lg';
+};
+declare const Heading: ({ children, size, className, ...rest }: HeadingProps) => React$1.JSX.Element;
+
+type DisplayProps = BaseTypographyProps & {
+    as?: ElementType;
+    size?: 'sm' | 'md' | 'lg';
+};
+declare const Display: ({ as, children, size, className, ...rest }: DisplayProps) => React$1.JSX.Element;
+
+type CodeProps = BaseTypographyProps & {
+    as?: ElementType;
+};
+declare const Code: ({ as, children, className, ...rest }: CodeProps) => React$1.JSX.Element;
+
+type LabelProps = BaseTypographyProps & {
+    as?: ElementType;
+    size?: 'xs' | 'sm';
+};
+declare const Label: ({ as, children, size, className, ...rest }: LabelProps) => React$1.JSX.Element;
+
+interface CheckboxProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'onChange'> {
+    indeterminate?: boolean;
+    error?: boolean;
+    label?: string;
+    value?: string;
+    disabled?: boolean;
+    onChange?: (selected: boolean) => void;
+}
+
+declare const Checkbox: ({ label, error, className, indeterminate, value, disabled, readOnly, defaultChecked, checked, ...props }: CheckboxProps) => React$1.JSX.Element;
+//# sourceMappingURL=Checkbox.d.ts.map
+
+interface CheckboxGroupProps extends Pick<AriaCheckboxGroupProps, 'aria-describedby' | 'aria-details' | 'aria-errormessage' | 'aria-label' | 'aria-labelledby' | 'onBlur' | 'onFocus' | 'onChange' | 'onFocusChange' | 'value' | 'defaultValue' | 'label'> {
+    children: ReactNode;
+    className?: string;
+    disabled?: boolean;
+    errorMessage?: string;
+    helperText?: string;
+    name: string;
+}
+declare const CheckboxGroup: ({ helperText, className, errorMessage, children, disabled, label, defaultValue, name, ...props }: CheckboxGroupProps) => React$1.JSX.Element;
+
+interface RadioProps extends React$1.InputHTMLAttributes<HTMLInputElement> {
+    label: string;
+    indent?: boolean;
+    disabled?: boolean;
+    invalid?: boolean;
+}
+declare const Radio: ({ indent, disabled, invalid, label, ...props }: RadioProps) => React$1.JSX.Element;
+//# sourceMappingURL=Radio.d.ts.map
+
+type RadioGroupProps = Pick<AriaRadioGroupProps, 'aria-describedby' | 'aria-details' | 'aria-errormessage' | 'aria-label' | 'aria-labelledby' | 'onBlur' | 'onFocus' | 'onChange' | 'onFocusChange' | 'value' | 'defaultValue'> & {
+    label?: string;
+    name: string;
+    errorMessage?: string;
+    helperText?: string;
+    children: React$1.ReactNode;
+    disabled?: boolean;
+    invalid?: boolean;
+    defaultValue?: string;
+};
+declare const RadioGroup: ({ children, label, errorMessage, helperText, disabled, invalid, name, defaultValue, ...props }: RadioGroupProps) => React$1.JSX.Element;
+//# sourceMappingURL=RadioGroup.d.ts.map
+
+interface TextInputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'size' | 'autoCapitalize' | 'onChange'> {
+    label?: string;
+    size?: 'sm' | 'md' | 'lg' | 'xl';
+    fullWidth?: boolean;
+    disabled?: boolean;
+    invalid?: boolean;
+    readOnly?: boolean;
+    helperText?: string;
+    errorMessage?: string;
+    leadingElement?: ReactNode;
+    trailingElement?: ReactNode;
+    onChange: (value: string) => void;
+    showErrorMessage?: boolean;
+}
+declare const TextInput: React$1.ForwardRefExoticComponent<TextInputProps & React$1.RefAttributes<unknown>>;
+//# sourceMappingURL=TextInput.d.ts.map
+
+type Option = {
+    value: string;
+    label: string;
+    disabled?: boolean;
+};
+interface SelectProps extends Omit<React.SelectHTMLAttributes<HTMLSelectElement>, 'size'> {
+    label?: string;
+    size?: 'sm' | 'md' | 'lg' | 'xl';
+    disabled?: boolean;
+    inline?: boolean;
+    helperText?: string;
+    errorMessage?: string;
+    options: Option[];
+    fullWidth?: boolean;
+}
+
+declare const Select: ({ options, label, size, inline, disabled, helperText, errorMessage, fullWidth, ...props }: SelectProps) => React$1.JSX.Element;
+//# sourceMappingURL=Select.d.ts.map
+
+type FormErrorMessageProps = React$1.HtmlHTMLAttributes<HTMLDivElement>;
+declare const FormErrorMessage: ({ children, className, ...props }: FormErrorMessageProps) => React$1.JSX.Element;
+//# sourceMappingURL=FormErrorMessage.d.ts.map
+
+declare const FormHelperText: ({ children, className, ...props }: React$1.HtmlHTMLAttributes<HTMLDivElement>) => React$1.JSX.Element;
+//# sourceMappingURL=FormHelperText.d.ts.map
+
+type ChipProps = AriaToggleButtonProps & {
+    label: string;
+    title?: string;
+    onDismiss?: () => void;
+    dismissLabel?: string;
+    leadingIcon?: IconVariant;
+    trailingIcon?: IconVariant;
+};
+
+declare const Chip: ({ label, onDismiss, dismissLabel, leadingIcon, trailingIcon, title, ...props }: ChipProps) => React$1.JSX.Element;
+//# sourceMappingURL=Chip.d.ts.map
+
+type FlexBasisValue = 'auto' | '1/2' | '1/3' | '2/3' | '1/4' | '2/4' | '3/4' | '1/5' | '2/5' | '3/5' | '4/5' | '1/6' | '2/6' | '3/6' | '4/6' | '5/6' | '1/12' | '2/12' | '3/12' | '4/12' | '5/12' | '6/12' | '7/12' | '8/12' | '9/12' | '10/12' | '11/12' | 'full';
+type GapValue = 0 | 'px' | 0.5 | 1 | 1.5 | 2 | 2.5 | 3 | 3.5 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 14 | 16 | 20 | 24 | 28 | 32 | 36 | 40 | 44 | 48 | 52 | 56 | 60 | 64 | 72 | 80 | 96;
+type FlexProps = {
+    children?: React.ReactNode;
+    flexDirection?: 'row' | 'row-reverse' | 'col' | 'col-reverse';
+    wrap?: 'nowrap' | 'wrap' | 'wrap-reverse';
+    alignItems?: 'start' | 'end' | 'center' | 'baseline' | 'stretch';
+    justifyContent?: 'normal' | 'start' | 'end' | 'center' | 'between' | 'around' | 'evenly' | 'stretch';
+    basis?: FlexBasisValue;
+    flex?: 'initial' | 'none' | 'auto' | 1;
+    grow?: boolean;
+    shrink?: boolean;
+    gap?: GapValue;
+    gapX?: GapValue;
+    gapY?: GapValue;
+    className?: string;
+} & React.HTMLAttributes<HTMLDivElement>;
+
+declare const Flex: ({ basis, flex, flexDirection, wrap, grow, shrink, gap, gapX, gapY, className, children, alignItems, justifyContent, ...props }: FlexProps) => React$1.JSX.Element;
+//# sourceMappingURL=Flex.d.ts.map
+
+type TemplateColRowValues = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 'none' | 'subgrid';
+type GridColVariant = TemplateColRowValues;
+type GridRowVariant = TemplateColRowValues;
+type AutoColRowVariant = 'auto' | 'min' | 'max' | 'fr';
+type GridColRowStartEndSizes = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13;
+type GridColumnRowVariant = 'auto' | 'full' | GridColRowStartEndSizes;
+type GridColumnRowStartEndVariant = 'auto' | GridColRowStartEndSizes;
+type GapSize = 0 | 'px' | 0.5 | 1 | 1.5 | 2 | 2.5 | 3 | 3.5 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 14 | 16 | 20 | 24 | 28 | 32 | 36 | 40 | 44 | 48 | 52 | 56 | 60 | 64 | 72 | 80 | 96;
+type GapVariant = GapSize;
+type BaseContentValues = 'start' | 'end' | 'center' | 'between' | 'around' | 'evenly' | 'stretch';
+type JustifyContentVariant = BaseContentValues | 'normal';
+type BaseItemsValues = 'start' | 'end' | 'center' | 'stretch';
+type AlignItemsVariant = BaseItemsValues | 'baseline';
+type GridProps = {
+    children: ReactNode;
+    inline?: boolean;
+    templateColumns?: GridColVariant;
+    templateRows?: GridRowVariant;
+    column?: GridColumnRowVariant;
+    columnStart?: GridColumnRowStartEndVariant;
+    columnEnd?: GridColumnRowStartEndVariant;
+    row?: GridColumnRowVariant;
+    rowStart?: GridColumnRowStartEndVariant;
+    rowEnd?: GridColumnRowStartEndVariant;
+    autoColumns?: AutoColRowVariant;
+    autoRows?: AutoColRowVariant;
+    gap?: GapVariant;
+    gapX?: GapVariant;
+    gapY?: GapVariant;
+    justifyContent?: JustifyContentVariant;
+    alignItems?: AlignItemsVariant;
+} & React.HTMLAttributes<HTMLDivElement>;
+//# sourceMappingURL=types.d.ts.map
+
+declare const Grid: ({ children, templateColumns, templateRows, autoColumns, autoRows, inline, column, columnStart, columnEnd, row, rowStart, rowEnd, gap, gapX, gapY, className, justifyContent, alignItems, ...props }: GridProps) => React$1.JSX.Element;
+//# sourceMappingURL=Grid.d.ts.map
+
+type ListBoxProps<T extends object = object> = ListBoxProps$1<T>;
+type ListBoxItemProps = ListBoxItemProps$1;
+type ListBoxSectionProps<T extends object = object> = ListBoxSectionProps$1<T>;
+type ListBoxHeaderProps = HeaderProps;
+
+declare const ListBoxRoot: {
+    ({ className, ...props }: ListBoxProps): React$1.JSX.Element;
+    displayName: string;
+};
+declare const ListBoxItem: {
+    ({ className, ...props }: ListBoxItemProps): React$1.JSX.Element;
+    displayName: string;
+};
+declare const ListBoxSection: {
+    ({ className, ...props }: ListBoxSectionProps): React$1.JSX.Element;
+    displayName: string;
+};
+declare const ListBoxHeader: {
+    ({ className, ...props }: ListBoxHeaderProps): React$1.JSX.Element;
+    displayName: string;
+};
+type ListBoxComponent = typeof ListBoxRoot & {
+    Item: typeof ListBoxItem;
+    Section: typeof ListBoxSection;
+    Header: typeof ListBoxHeader;
+};
+declare const ListBox: ListBoxComponent;
+
+type Sentiment = 'success' | 'danger';
+type AuthLayoutProps = {
+    children: React.ReactNode;
+    heading: string;
+    description?: string | React.ReactNode;
+    sentiment?: Sentiment;
+    leadingElement?: React.ReactNode;
+    alert?: AlertProps;
+    footer?: React.ReactNode;
+    topAddon?: React.ReactNode;
+};
+
+declare const AuthLayout: ({ children, heading, description, sentiment, leadingElement, alert, topAddon, footer, }: AuthLayoutProps) => React$1.JSX.Element;
+//# sourceMappingURL=AuthLayout.d.ts.map
+
+export { ActionList, Alert, AuthLayout, Avatar, Banner, Body, Breadcrumbs, BreadcrumbsItem, Button, Card, Checkbox, CheckboxGroup, Chip, Code, DataTable, Display, Flex, FormErrorMessage, FormHelperText, GlobalToastProvider, Grid, Heading, Icon, IconButton, Label, Link, ListBox, LoadingSpinner, Logo, Menu, MenuButton, MenuList, OverlayTrigger, Pagination, Popover, ProgressBar, Radio, RadioGroup, Select, SideNavWrapper as SideNav, Tab, TabList, TabPanel, TabPanels, Tabs, Tag, TextInput, Tile, ToastProvider, ToastQueue, Toggle, Tooltip, TooltipTrigger, TopBar, useHover, useOverlayTrigger, useToast, useWindowSize };
+export type { Interactions, OverlayAriaRole, Placement, PopoverProps };