@buildo/bento-design-system/lib/index.d.ts

The buildo DS

import * as react_jsx_runtime from 'react/jsx-runtime';
import { I as IconProps, L as LocalizedString, A as ActionsConfig, a as AreaLoaderConfig, b as AvatarConfig, c as BannerConfig, d as BreadcrumbConfig, e as ButtonConfig, C as CardConfig, f as ChartConfig, g as ChipConfig, D as DecorativeDividerConfig, h as DisclosureConfig, i as DisclosureGroupConfig, F as FeedbackConfig, j as FieldConfig, k as FileUploaderFieldConfig, l as InlineLoaderConfig, m as InputConfig, S as SelectionControlGroupConfig, n as SelectionControlConfig, o as FormLayoutConfig, p as IconButtonConfig, q as ListConfig, M as MenuConfig, r as ModalConfig, N as NavigationConfig, P as PaginationConfig, R as ReadOnlyFieldConfig, s as SearchBarConfig, t as DropdownConfig, T as TableConfig, u as ToastConfig, v as TabsConfig, w as ProgressBarConfig, x as SliderConfig, y as StepperConfig, z as TooltipConfig, E as DateFieldConfig, G as Children, H as CardElevation, J as BorderRadiusConfig, K as BentoSprinkles, O as ChartDataColor, Q as Omit$1, U as FieldProps, V as RequiredResponsiveValue, W as Props$M, X as Props$N, Y as NonEmptyArray, Z as Props$O, _ as Props$P, $ as ResponsiveSpace, a0 as OptionalResponsiveValue, a1 as AsProp, a2 as Box, a3 as Kind, a4 as LeftItem, a5 as CommonItemProps, a6 as ListItemProps, a7 as Props$Q, a8 as PaginationItemsPerPage, a9 as BaseSelectProps, aa as BaseMultiProps, ab as BaseSingleProps, ac as Column$2, ad as Props$R, ae as Props$S, af as Props$T, ag as LabelProps, ah as Props$U, ai as GroupedColumn, aj as Row, ak as Props$V, al as TooltipPlacement, am as PartialDeep, an as BentoTokens, ao as DefaultMessages, ap as PartialBentoConfig, aq as BentoTheme, ar as BentoConfig, as as bentoSprinkles, at as SprinklesFn, au as Actions, av as Banner, aw as Body, ax as BoxType, ay as Button, az as ButtonLink, aA as Chip, aB as CustomModal, aC as LinkComponentProps, aD as ButtonSize, aE as TypographySize, aF as TypographyColor, aG as Disclosure, aH as Display, aI as Feedback, aJ as Headline, aK as IconButton, aL as Label, aM as Link, aN as List, aO as ListSize, aP as Modal, aQ as Navigation, aR as SelectField, aS as Tabs, aT as Title } from './BentoConfig-f5278c12.js';
export { aW as BannerProps, B as BentoProvider, a_ as BentoThemeContext, b1 as BentoThemePortalProvider, b0 as BentoThemeProvider, aV as ChipCustomColors, bj as ConfiguredTypes, aV as CustomChipColors, bq as DefaultLinkComponent, aZ as DesignSystemProvider, bg as DisplayProps, b3 as FeedbackSize, bh as HeadlineProps, aX as Kind, bp as LinkComponent, br as LinkComponentContext, b4 as LinkProps, b6 as ListItem, b5 as ListRightItem, b9 as ModalKind, b7 as ModalProps, b8 as ModalSize, ba as NavigationProps, bb as NavigationSize, b2 as OtherButtonKeys, bd as SelectFieldProps, bc as SelectOption, be as TabsProps, bf as TabsSize, bi as TitleProps, aU as TypeOverrides, bm as allColors, aY as createBentoProvider, bo as makeLinkComponent, bl as responsiveProperties, bn as statusProperties, bk as unconditionalProperties, a$ as useBentoTheme, bs as useLinkComponent, bt as vars } from './BentoConfig-f5278c12.js';
import { ResponsiveContainerProps, TooltipProps, LegendProps, BarProps, LineProps, PieProps, CellProps } from 'recharts';
import { CSSVarFunction } from '@vanilla-extract/private';
import * as react from 'react';
import { ReactElement, HTMLAttributes, ComponentProps, DOMAttributes, ElementType, LabelHTMLAttributes, PropsWithoutRef, SVGProps, Ref, RefObject, OutputHTMLAttributes } from 'react';
import { Payload } from 'recharts/types/component/DefaultLegendContent';
import { CalendarState, RangeCalendarState } from '@react-stately/calendar';
import { AriaButtonProps } from '@react-types/button';
import { FocusableElement, AriaLabelingProps, DOMProps } from '@react-types/shared';
import { AriaCalendarProps, DateValue, AriaRangeCalendarProps } from '@react-types/calendar';
import { ErrorCode as ErrorCode$1 } from 'react-dropzone';
import { MenuTriggerState } from '@react-stately/menu';
export { MenuTriggerState } from '@react-stately/menu';
import * as _react_types_overlays from '@react-types/overlays';
import { Placement } from '@react-types/overlays';
export { Placement } from '@react-types/overlays';
import { NumberFieldStateOptions } from '@react-stately/numberfield';
import { SliderState } from '@react-stately/slider';
import { Column as Column$1, CellProps as CellProps$1, SortingRule, Row as Row$1 } from 'react-table';
export { CellProps as TableCellProps, Column as TableColumn, Row as TableRow } from 'react-table';
import { Time } from '@internationalized/date';
export { CalendarDate, DateValue, Time } from '@internationalized/date';
import { ComplexStyleRule } from '@vanilla-extract/css';
export { ClassValue } from 'clsx';
import '@vanilla-extract/sprinkles';
import 'react-select';

declare function IconBell(props: IconProps): react_jsx_runtime.JSX.Element;

declare function IconBin(props: IconProps): react_jsx_runtime.JSX.Element;

declare function IconCalendar(props: IconProps): react_jsx_runtime.JSX.Element;

declare function IconCheck(props: IconProps): react_jsx_runtime.JSX.Element;

declare function IconChevronDown(props: IconProps): react_jsx_runtime.JSX.Element;

declare function IconChevronLeft(props: IconProps): react_jsx_runtime.JSX.Element;

declare function IconChevronRight(props: IconProps): react_jsx_runtime.JSX.Element;

declare function IconChevronUp(props: IconProps): react_jsx_runtime.JSX.Element;

declare function IconClock(props: IconProps): react_jsx_runtime.JSX.Element;

declare function IconCopy(props: IconProps): react_jsx_runtime.JSX.Element;

declare function IconDownload(props: IconProps): react_jsx_runtime.JSX.Element;

declare function IconEye(props: IconProps): react_jsx_runtime.JSX.Element;

declare function IconEyeClosed(props: IconProps): react_jsx_runtime.JSX.Element;

declare function IconFile(props: IconProps): react_jsx_runtime.JSX.Element;

declare function IconGear(props: IconProps): react_jsx_runtime.JSX.Element;

declare function IconHome(props: IconProps): react_jsx_runtime.JSX.Element;

declare function IconHorizontalDots(props: IconProps): react_jsx_runtime.JSX.Element;

declare function IconInfo(props: IconProps): react_jsx_runtime.JSX.Element;

declare function IconInfoCircle(props: IconProps): react_jsx_runtime.JSX.Element;

declare function IconInfoSolid(props: IconProps): react_jsx_runtime.JSX.Element;

declare function IconLightbulb(props: IconProps): react_jsx_runtime.JSX.Element;

declare function IconLightbulbSolid(props: IconProps): react_jsx_runtime.JSX.Element;

declare function IconList(props: IconProps): react_jsx_runtime.JSX.Element;

declare function IconLogout(props: IconProps): react_jsx_runtime.JSX.Element;

declare function IconMinus(props: IconProps): react_jsx_runtime.JSX.Element;

declare function IconNegative(props: IconProps): react_jsx_runtime.JSX.Element;

declare function IconNegativeSolid(props: IconProps): react_jsx_runtime.JSX.Element;

declare function IconPencil(props: IconProps): react_jsx_runtime.JSX.Element;

declare function IconPlaceholder(props: IconProps): react_jsx_runtime.JSX.Element;

declare function IconPlus(props: IconProps): react_jsx_runtime.JSX.Element;

declare function IconPositiveCircle(props: IconProps): react_jsx_runtime.JSX.Element;

declare function IconPositiveSolid(props: IconProps): react_jsx_runtime.JSX.Element;

declare function IconQuestionCircle(props: IconProps): react_jsx_runtime.JSX.Element;

declare function IconQuestionSolid(props: IconProps): react_jsx_runtime.JSX.Element;

declare function IconSearch(props: IconProps): react_jsx_runtime.JSX.Element;

declare function IconSpinner(props: IconProps): react_jsx_runtime.JSX.Element;

declare function IconStar(props: IconProps): react_jsx_runtime.JSX.Element;

declare function IconUser(props: IconProps): react_jsx_runtime.JSX.Element;

declare function IconVerticalDots(props: IconProps): react_jsx_runtime.JSX.Element;

declare function IconWarningCircle(props: IconProps): react_jsx_runtime.JSX.Element;

declare function IconWarningSolid(props: IconProps): react_jsx_runtime.JSX.Element;

declare function IconX(props: IconProps): react_jsx_runtime.JSX.Element;

declare const index_IconBell: typeof IconBell;
declare const index_IconBin: typeof IconBin;
declare const index_IconCalendar: typeof IconCalendar;
declare const index_IconCheck: typeof IconCheck;
declare const index_IconChevronDown: typeof IconChevronDown;
declare const index_IconChevronLeft: typeof IconChevronLeft;
declare const index_IconChevronRight: typeof IconChevronRight;
declare const index_IconChevronUp: typeof IconChevronUp;
declare const index_IconClock: typeof IconClock;
declare const index_IconCopy: typeof IconCopy;
declare const index_IconDownload: typeof IconDownload;
declare const index_IconEye: typeof IconEye;
declare const index_IconEyeClosed: typeof IconEyeClosed;
declare const index_IconFile: typeof IconFile;
declare const index_IconGear: typeof IconGear;
declare const index_IconHome: typeof IconHome;
declare const index_IconHorizontalDots: typeof IconHorizontalDots;
declare const index_IconInfo: typeof IconInfo;
declare const index_IconInfoCircle: typeof IconInfoCircle;
declare const index_IconInfoSolid: typeof IconInfoSolid;
declare const index_IconLightbulb: typeof IconLightbulb;
declare const index_IconLightbulbSolid: typeof IconLightbulbSolid;
declare const index_IconList: typeof IconList;
declare const index_IconLogout: typeof IconLogout;
declare const index_IconMinus: typeof IconMinus;
declare const index_IconNegative: typeof IconNegative;
declare const index_IconNegativeSolid: typeof IconNegativeSolid;
declare const index_IconPencil: typeof IconPencil;
declare const index_IconPlaceholder: typeof IconPlaceholder;
declare const index_IconPlus: typeof IconPlus;
declare const index_IconPositiveCircle: typeof IconPositiveCircle;
declare const index_IconPositiveSolid: typeof IconPositiveSolid;
declare const index_IconProps: typeof IconProps;
declare const index_IconQuestionCircle: typeof IconQuestionCircle;
declare const index_IconQuestionSolid: typeof IconQuestionSolid;
declare const index_IconSearch: typeof IconSearch;
declare const index_IconSpinner: typeof IconSpinner;
declare const index_IconStar: typeof IconStar;
declare const index_IconUser: typeof IconUser;
declare const index_IconVerticalDots: typeof IconVerticalDots;
declare const index_IconWarningCircle: typeof IconWarningCircle;
declare const index_IconWarningSolid: typeof IconWarningSolid;
declare const index_IconX: typeof IconX;
declare namespace index {
  export {
    index_IconBell as IconBell,
    index_IconBin as IconBin,
    index_IconCalendar as IconCalendar,
    index_IconCheck as IconCheck,
    index_IconChevronDown as IconChevronDown,
    index_IconChevronLeft as IconChevronLeft,
    index_IconChevronRight as IconChevronRight,
    index_IconChevronUp as IconChevronUp,
    index_IconClock as IconClock,
    index_IconCopy as IconCopy,
    index_IconDownload as IconDownload,
    index_IconEye as IconEye,
    index_IconEyeClosed as IconEyeClosed,
    index_IconFile as IconFile,
    index_IconGear as IconGear,
    index_IconHome as IconHome,
    index_IconHorizontalDots as IconHorizontalDots,
    index_IconInfo as IconInfo,
    index_IconInfoCircle as IconInfoCircle,
    index_IconInfoSolid as IconInfoSolid,
    index_IconLightbulb as IconLightbulb,
    index_IconLightbulbSolid as IconLightbulbSolid,
    index_IconList as IconList,
    index_IconLogout as IconLogout,
    index_IconMinus as IconMinus,
    index_IconNegative as IconNegative,
    index_IconNegativeSolid as IconNegativeSolid,
    index_IconPencil as IconPencil,
    index_IconPlaceholder as IconPlaceholder,
    index_IconPlus as IconPlus,
    index_IconPositiveCircle as IconPositiveCircle,
    index_IconPositiveSolid as IconPositiveSolid,
    index_IconProps as IconProps,
    index_IconQuestionCircle as IconQuestionCircle,
    index_IconQuestionSolid as IconQuestionSolid,
    index_IconSearch as IconSearch,
    index_IconSpinner as IconSpinner,
    index_IconStar as IconStar,
    index_IconUser as IconUser,
    index_IconVerticalDots as IconVerticalDots,
    index_IconWarningCircle as IconWarningCircle,
    index_IconWarningSolid as IconWarningSolid,
    index_IconX as IconX,
  };
}

type StrictLocalizedString = string & {
    readonly LocalizedString: "LocalizedString";
};
declare function unsafeLocalizedString(n: number | string): LocalizedString;

declare const statusPropertiesConditions: {
    readonly default: {};
    readonly hover: {
        readonly selector: "&:hover:not(:disabled):not([disabled])";
    };
    readonly focus: {
        readonly selector: "&:focus:not(:disabled):not([disabled])";
    };
    readonly active: {
        readonly selector: "&:active:not(:disabled):not([disabled])";
    };
    readonly disabled: {
        readonly selector: "&:disabled, &[disabled], :disabled &, [disabled] &";
    };
};
declare const statusPropertiesDefaultCondition: "default";
declare const responsivePropertiesConditions: {
    wide: {};
    desktop: {
        "@media": string;
    };
    tablet: {
        "@media": string;
    };
    mobile: {
        "@media": string;
    };
};
declare const responsivePropertiesDefaultCondition: "wide";

declare const unconditionalPropertiesShorthands: {
    borderTopRadius: ["borderTopLeftRadius", "borderTopRightRadius"];
    borderBottomRadius: ["borderBottomLeftRadius", "borderBottomRightRadius"];
};
declare const responsivePropertiesShorthands: {
    inset: ["top", "right", "bottom", "left"];
    padding: ["paddingTop", "paddingBottom", "paddingLeft", "paddingRight"];
    paddingX: ["paddingLeft", "paddingRight"];
    paddingY: ["paddingTop", "paddingBottom"];
    margin: ["marginTop", "marginBottom", "marginLeft", "marginRight"];
    marginX: ["marginLeft", "marginRight"];
    marginY: ["marginTop", "marginBottom"];
};

declare const actions: ActionsConfig;
declare const areaLoader: AreaLoaderConfig;
declare const avatar: AvatarConfig;
declare const banner: BannerConfig;
declare const breadcrumb: BreadcrumbConfig;
declare const button$1: ButtonConfig;
declare const card: CardConfig;
declare const chart: ChartConfig;
declare const chip$1: ChipConfig;
declare const decorativeDivider: DecorativeDividerConfig;
declare const disclosure: DisclosureConfig;
declare const disclosureGroup: DisclosureGroupConfig;
declare const feedback: FeedbackConfig;
declare const field: FieldConfig;
declare const fileUploaderField: FileUploaderFieldConfig;
declare const inlineLoader: InlineLoaderConfig;
declare const input: InputConfig;
declare const selectionControl: {
    group: SelectionControlGroupConfig;
    element: SelectionControlConfig;
};
declare const formLayout: FormLayoutConfig;
declare const iconButton$1: IconButtonConfig;
declare const list: ListConfig;
declare const menu: MenuConfig;
declare const modal: ModalConfig;
declare const navigation: NavigationConfig;
declare const pagination: PaginationConfig;
declare const readOnlyField: ReadOnlyFieldConfig;
declare const searchBar: SearchBarConfig;
declare const dropdown: DropdownConfig;
declare const table: TableConfig;
declare const toast: ToastConfig;
declare const folderTabs: TabsConfig;
declare const underlineTabs: TabsConfig;
declare const tabs: TabsConfig;
declare const progressBar: ProgressBarConfig;
declare const slider: SliderConfig;
declare const stepper: StepperConfig;
declare const tooltip: TooltipConfig;
declare const dateField: DateFieldConfig;

declare const defaultConfigs_actions: typeof actions;
declare const defaultConfigs_areaLoader: typeof areaLoader;
declare const defaultConfigs_avatar: typeof avatar;
declare const defaultConfigs_banner: typeof banner;
declare const defaultConfigs_breadcrumb: typeof breadcrumb;
declare const defaultConfigs_card: typeof card;
declare const defaultConfigs_chart: typeof chart;
declare const defaultConfigs_dateField: typeof dateField;
declare const defaultConfigs_decorativeDivider: typeof decorativeDivider;
declare const defaultConfigs_disclosure: typeof disclosure;
declare const defaultConfigs_disclosureGroup: typeof disclosureGroup;
declare const defaultConfigs_dropdown: typeof dropdown;
declare const defaultConfigs_feedback: typeof feedback;
declare const defaultConfigs_field: typeof field;
declare const defaultConfigs_fileUploaderField: typeof fileUploaderField;
declare const defaultConfigs_folderTabs: typeof folderTabs;
declare const defaultConfigs_formLayout: typeof formLayout;
declare const defaultConfigs_inlineLoader: typeof inlineLoader;
declare const defaultConfigs_input: typeof input;
declare const defaultConfigs_list: typeof list;
declare const defaultConfigs_menu: typeof menu;
declare const defaultConfigs_modal: typeof modal;
declare const defaultConfigs_navigation: typeof navigation;
declare const defaultConfigs_pagination: typeof pagination;
declare const defaultConfigs_progressBar: typeof progressBar;
declare const defaultConfigs_readOnlyField: typeof readOnlyField;
declare const defaultConfigs_searchBar: typeof searchBar;
declare const defaultConfigs_selectionControl: typeof selectionControl;
declare const defaultConfigs_slider: typeof slider;
declare const defaultConfigs_stepper: typeof stepper;
declare const defaultConfigs_table: typeof table;
declare const defaultConfigs_tabs: typeof tabs;
declare const defaultConfigs_toast: typeof toast;
declare const defaultConfigs_tooltip: typeof tooltip;
declare const defaultConfigs_underlineTabs: typeof underlineTabs;
declare namespace defaultConfigs {
  export {
    defaultConfigs_actions as actions,
    defaultConfigs_areaLoader as areaLoader,
    defaultConfigs_avatar as avatar,
    defaultConfigs_banner as banner,
    defaultConfigs_breadcrumb as breadcrumb,
    button$1 as button,
    defaultConfigs_card as card,
    defaultConfigs_chart as chart,
    chip$1 as chip,
    defaultConfigs_dateField as dateField,
    defaultConfigs_decorativeDivider as decorativeDivider,
    defaultConfigs_disclosure as disclosure,
    defaultConfigs_disclosureGroup as disclosureGroup,
    defaultConfigs_dropdown as dropdown,
    defaultConfigs_feedback as feedback,
    defaultConfigs_field as field,
    defaultConfigs_fileUploaderField as fileUploaderField,
    defaultConfigs_folderTabs as folderTabs,
    defaultConfigs_formLayout as formLayout,
    iconButton$1 as iconButton,
    defaultConfigs_inlineLoader as inlineLoader,
    defaultConfigs_input as input,
    defaultConfigs_list as list,
    defaultConfigs_menu as menu,
    defaultConfigs_modal as modal,
    defaultConfigs_navigation as navigation,
    defaultConfigs_pagination as pagination,
    defaultConfigs_progressBar as progressBar,
    defaultConfigs_readOnlyField as readOnlyField,
    defaultConfigs_searchBar as searchBar,
    defaultConfigs_selectionControl as selectionControl,
    defaultConfigs_slider as slider,
    defaultConfigs_stepper as stepper,
    defaultConfigs_table as table,
    defaultConfigs_tabs as tabs,
    defaultConfigs_toast as toast,
    defaultConfigs_tooltip as tooltip,
    defaultConfigs_underlineTabs as underlineTabs,
  };
}

type Props$L = {
    message?: LocalizedString;
};

declare function AreaLoader({ message }: Props$L): react_jsx_runtime.JSX.Element;

type Props$K = {
    name?: string;
    color: "grey" | "red" | "orange" | "yellow" | "green" | "jade" | "blue" | "indigo" | "violet" | "pink";
};

declare function Avatar({ color, name }: Props$K): react_jsx_runtime.JSX.Element;

type LastItem = {
    label: LocalizedString;
};
type Item = LastItem & {
    href: string;
};
type Props$J = {
    items: [...Item[], LastItem];
};
declare function Breadcrumb(props: Props$J): react_jsx_runtime.JSX.Element;

type PaddingKey = "padding" | "paddingX" | "paddingY" | "paddingLeft" | "paddingRight" | "paddingTop" | "paddingBottom";
type Props$I = {
    children: Children;
    elevation?: CardElevation;
    borderRadius?: BorderRadiusConfig;
    background?: BentoSprinkles["background"];
} & {
    [k in PaddingKey]?: 0 | BentoSprinkles["padding"];
};
declare function Card({ children, elevation, borderRadius, ...boxProps }: Props$I): react_jsx_runtime.JSX.Element;

type ChartProps = {
    dataColors?: ChartDataColor[];
    disableAnimation?: boolean;
    hideLegend?: boolean;
    hideTooltip?: boolean;
    children?: Children;
} & Pick<ResponsiveContainerProps, "width" | "height" | "minWidth" | "minHeight" | "maxHeight" | "aspect" | "debounce">;

type NameType = number | string;
type ValueType = number | string;
type ValueFormatter = (value: ValueType) => string;

type Props$H<D extends string, C extends string> = ChartProps & {
    data: Record<D | C, unknown>[];
    categories: C[];
    dataKey: D;
    hideXAxis?: boolean;
    hideYAxis?: boolean;
    stacked?: boolean;
    xAxisValueFormatter?: ValueFormatter;
    yAxisValueFormatter?: ValueFormatter;
};

declare function BarChart<D extends string, C extends string>({ data, dataKey, categories, hideXAxis, hideYAxis, hideLegend, disableAnimation, hideTooltip, width, height, minWidth, minHeight, maxHeight, aspect, debounce, stacked, dataColors, children, xAxisValueFormatter, yAxisValueFormatter, }: Props$H<D, C>): react_jsx_runtime.JSX.Element;

type Props$G<D extends string, C extends string> = ChartProps & {
    data: Record<C | D, unknown>[];
    category: C;
    dataKey: D;
    tooltipFormatter?: ValueFormatter;
};

declare function DonutChart<D extends string, C extends string>({ data, dataKey, category, hideLegend, disableAnimation, hideTooltip, width, height, minWidth, minHeight, maxHeight, aspect, debounce, dataColors, children, tooltipFormatter, }: Props$G<D, C>): react_jsx_runtime.JSX.Element;

type Props$F<D extends string, C extends string> = ChartProps & {
    data: Record<D | C, unknown>[];
    categories: C[];
    dataKey: D;
    hideXAxis?: boolean;
    hideYAxis?: boolean;
    lineType?: "linear" | "natural" | "monotoneX" | "monotoneY" | "monotone" | "step" | "stepBefore" | "stepAfter";
    xAxisValueFormatter?: ValueFormatter;
    yAxisValueFormatter?: ValueFormatter;
};

declare function LineChart<D extends string, C extends string>({ data, dataKey, categories, hideXAxis, hideYAxis, hideLegend, disableAnimation, hideTooltip, width, height, minWidth, minHeight, maxHeight, aspect, debounce, lineType, dataColors, children, xAxisValueFormatter, yAxisValueFormatter, }: Props$F<D, C>): react_jsx_runtime.JSX.Element;

type ChartTools<TValue extends ValueType, TName extends NameType> = {
    colorPalette: Array<CSSVarFunction>;
    defaultConfig: ChartConfig;
    legendContent: Required<LegendProps>["content"];
    makeLegendEntry: (entry: Payload) => JSX.Element;
    containerProps: Pick<ResponsiveContainerProps, "className">;
    makeBarProps: (i: number) => Pick<BarProps, "fill">;
    makeLineProps: (i: number) => Pick<LineProps, "stroke" | "strokeWidth" | "dot">;
    pieProps: Pick<PieProps, "cx" | "cy" | "startAngle" | "endAngle" | "innerRadius" | "outerRadius" | "paddingAngle" | "stroke">;
    makePieCellProps: (i: number) => Pick<CellProps, "fill">;
    tooltip: ReactElement<TooltipProps<TValue, TName>>;
    TooltipContentWrapper: React.FunctionComponent<{
        children: Children;
    }>;
    tooltipWrapperStyle: React.CSSProperties;
};
declare function useChart<TValue extends ValueType, TName extends NameType>({ customColors, tooltipOptions, }: {
    customColors?: Array<ChartDataColor>;
    tooltipOptions?: Omit$1<TooltipProps<TValue, TName>, "wrapperStyle" | "content">;
}): ChartTools<TValue, TName>;

declare type OptionalFlat<O> = {
    [K in keyof O]?: O[K];
} & {};
declare type RequiredFlat<O> = {
    [K in keyof O]-?: O[K];
} & {};
declare type Extends<A1 extends any, A2 extends any> = [A1] extends [never] ? 0 : A1 extends A2 ? 1 : 0;
declare type RequiredIfKeys<O extends object, K extends string> = Extends<keyof O & K, K> extends 1 ? RequiredFlat<O> : O;
declare type __AtLeast<O extends object, K extends string> = K extends keyof O ? Pick<O, K> & OptionalFlat<O> : O;
declare type ComputeRaw<A extends any> = A extends Function ? A : {
    [K in keyof A]: A[K];
} & unknown;
declare type _AtLeast<O extends object, K extends string> = ComputeRaw<__AtLeast<RequiredIfKeys<O, K>, K>>;
declare type AtLeast<O extends object, K extends string = keyof O & string> = O extends unknown ? _AtLeast<O, K> : never;

type Props$E = AtLeast<Pick<HTMLAttributes<HTMLInputElement>, "aria-label" | "aria-labelledby">> & Pick<FieldProps<boolean>, "value" | "onChange" | "disabled">;
declare function Checkbox({ value, disabled, ...props }: Props$E): react_jsx_runtime.JSX.Element;

type Props$D = Omit$1<FieldProps<boolean>, "assistiveText" | "label"> & {
    label: Children;
};
declare function CheckboxField(props: Props$D): react_jsx_runtime.JSX.Element;

type CheckboxOption = {
    value: string;
    label: Children;
    isDisabled?: boolean;
    autoFocus?: boolean;
};
type Props$C = FieldProps<string[]> & {
    label: Children;
    options: Array<CheckboxOption>;
    orientation?: "vertical" | "horizontal";
};
declare function CheckboxGroupField(props: Props$C): react_jsx_runtime.JSX.Element;

type Props$B = {
    maxWidth: RequiredResponsiveValue<700 | 1440>;
    alignSelf?: "center" | "left";
    children: Children;
};
declare function ContentBlock({ maxWidth, alignSelf, children }: Props$B): react_jsx_runtime.JSX.Element;

type Props$A = {
    children: [Children, Children];
    sidebarPosition: "right" | "left";
    sidebarWidth: ComponentProps<typeof Column>["width"] | {
        custom: string | number;
    };
    space?: BentoSprinkles["gap"];
    sidebarBackground?: BentoSprinkles["background"];
    sidebarAs?: Props$M["as"];
    contentAs?: Props$M["as"];
};
declare function ContentWithSidebar({ space, children, sidebarWidth, sidebarBackground, sidebarPosition, sidebarAs, contentAs, }: Props$A): react_jsx_runtime.JSX.Element;

type Props$z = (({
    type: "single";
} & AriaCalendarProps<DateValue>) | ({
    type: "range";
} & AriaRangeCalendarProps<DateValue>)) & {
    onClose: () => void;
    inputRef: React.RefObject<HTMLInputElement>;
    shortcuts: Children;
};
declare function CalendarPopover(props: ({
    type: "single";
    state: CalendarState;
} | {
    type: "range";
    state: RangeCalendarState;
}) & {
    prevButtonProps: AriaButtonProps<"button">;
    nextButtonProps: AriaButtonProps<"button">;
    onClose: () => void;
    calendarRef: React.RefObject<HTMLElement>;
    inputRef: React.RefObject<HTMLInputElement>;
    state: CalendarState | RangeCalendarState;
    shortcuts?: Children;
} & DOMAttributes<FocusableElement>): react.ReactPortal | null;
declare function Calendar(props: Props$z): react_jsx_runtime.JSX.Element;

type DateProps = {
    minDate?: Date;
    maxDate?: Date;
    shouldDisableDate?: (date: Date) => boolean;
    isReadOnly?: boolean;
    readOnly?: boolean;
};
type ShortcutProps<V> = {
    label: LocalizedString;
    value: V;
};
type SingleDateProps = {
    type?: "single";
    shortcuts?: ShortcutProps<Date | null>[];
};
type RangeDateProps = {
    type: "range";
    shortcuts?: ShortcutProps<[Date, Date] | null>[];
};

type SingleDateFieldProps = SingleDateProps & FieldProps<Date | null> & DateProps;
type RangeDateFieldProps = RangeDateProps & FieldProps<[Date, Date] | null> & DateProps;
type DateFieldProps = SingleDateFieldProps | RangeDateFieldProps;
declare function DateField(props: DateFieldProps): react_jsx_runtime.JSX.Element;

type StandaloneProps<T> = Pick<FieldProps<T>, "autoFocus" | "disabled" | "name" | "onBlur" | "onChange" | "value">;
type SingleDateInputProps = SingleDateProps & StandaloneProps<Date | null> & DateProps & {
    validationState?: "valid" | "invalid";
} & AtLeast<Pick<HTMLAttributes<HTMLInputElement>, "aria-label" | "aria-labelledby">>;
type RangeDateInputProps = RangeDateProps & StandaloneProps<[Date, Date] | null> & DateProps & {
    validationState?: "valid" | "invalid";
} & AtLeast<Pick<HTMLAttributes<HTMLInputElement>, "aria-label" | "aria-labelledby">>;
type DateInputProps = SingleDateInputProps | RangeDateInputProps;
declare function DateInput(props: SingleDateInputProps | RangeDateInputProps): react_jsx_runtime.JSX.Element;

type LeafItem = Omit$1<Props$N, "level" | "iconPosition">;
type NodeItem = Omit$1<LeafItem, "children"> & {
    items: Array<LeafItem>;
};
type Props$y = {
    iconPosition?: Props$N["iconPosition"];
    items: Array<NodeItem | LeafItem>;
    dividers?: boolean;
};

declare function DisclosureGroup({ items, iconPosition: iconPosition_, dividers }: Props$y): react_jsx_runtime.JSX.Element;

type Props$x = {
    orientation?: "horizontal" | "vertical";
};
declare function Divider({ orientation }: Props$x): react_jsx_runtime.JSX.Element;
declare function DecorativeDivider(): react_jsx_runtime.JSX.Element;

type Props$w = Pick<FieldProps<never>, "issues" | "disabled" | "assistiveText" | "hint" | "hintPlacement"> & {
    label?: FieldProps<never>["label"];
    labelElement?: ElementType<any>;
    labelProps?: LabelHTMLAttributes<HTMLLabelElement>;
    assistiveTextProps: DOMAttributes<FocusableElement>;
    errorMessageProps: DOMAttributes<FocusableElement>;
    children: Children;
};
declare function Field({ label, assistiveText, issues, labelProps, assistiveTextProps, errorMessageProps, children, disabled, labelElement, hint, hintPlacement, }: Props$w): react_jsx_runtime.JSX.Element;
type FieldType = React.FunctionComponent<Props$w>;

declare const errorCodes: readonly [ErrorCode$1.FileInvalidType, ErrorCode$1.FileTooLarge, ErrorCode$1.TooManyFiles];
type KnownDropzoneErrorCode = (typeof errorCodes)[number];
type ErrorCode = `${KnownDropzoneErrorCode}` | "generic-error" | "wrong-structure" | "unable-to-read";
type FileUploaderTexts = {
    title: LocalizedString;
    description: LocalizedString;
    uploadAgainMessage: LocalizedString;
    uploadingMessage: LocalizedString;
    uploadButtonLabel: LocalizedString;
    assistiveTextFileTypes: (allowedFileTypes?: Record<string, string[]>) => LocalizedString;
    assistiveTextMaxSize: (maxFileSizeMb?: number) => LocalizedString;
};
type FileResult<E extends string> = {
    readonly status: "valid";
    file: File;
} | {
    readonly status: "invalid";
    file: File;
    issues: NonEmptyArray<E | ErrorCode>;
};
type Props$v<E extends string> = {
    texts: FileUploaderTexts;
    renderIssue: (issue: E | ErrorCode, file?: File) => Children;
    issues?: NonEmptyArray<E>;
    maxFileSize?: number;
    allowedFileTypes?: Record<string, string[]>;
    validate?: (file: File) => Promise<E | null>;
    height?: string | number;
    isUploading?: boolean;
} & Omit<FieldProps<FileResult<E> | undefined>, "assistiveText" | "issues">;

declare function FileUploaderField<E extends string>({ label, validate, value, onChange, issues, texts, renderIssue, disabled, maxFileSize, allowedFileTypes, height: height_, isUploading, name, }: Props$v<E>): react_jsx_runtime.JSX.Element;

type Props$u = {
    children: Children;
    title?: LocalizedString;
    description?: Children;
    submitButton?: Omit<Props$O, "kind" | "hierarchy">;
    secondaryButton?: Omit<Props$O, "kind" | "hierarchy">;
    error?: LocalizedString;
    errorBannerWidth?: Props$P["errorBannerWidth"];
    actionsSize?: Props$O["size"];
    autoFocus?: boolean;
};
declare function Form({ title, description, children, submitButton, secondaryButton, error, errorBannerWidth: errorBannerWidth_, actionsSize: actionsSize_, autoFocus, }: Props$u): react_jsx_runtime.JSX.Element;

type Props$t = {
    children: Children;
};
declare function FormRow({ children }: Props$t): react_jsx_runtime.JSX.Element;

type Props$s = {
    title?: LocalizedString;
    description?: Children;
    children: Children;
};
declare function FormSection({ title, description, children }: Props$s): react_jsx_runtime.JSX.Element;

declare function svgIconProps({ size, color }: IconProps, sizeAxis?: "horizontal" | "vertical"): PropsWithoutRef<SVGProps<SVGSVGElement>>;

type Props$r = {
    message?: LocalizedString;
};

declare function InlineLoader({ message }: Props$r): react_jsx_runtime.JSX.Element;

type BleedProps = {
    children: Children;
    space?: ResponsiveSpace;
    spaceX?: ResponsiveSpace;
    spaceY?: ResponsiveSpace;
    spaceRight?: ResponsiveSpace;
    spaceLeft?: ResponsiveSpace;
    spaceTop?: ResponsiveSpace;
    spaceBottom?: ResponsiveSpace;
};
declare function Bleed({ space, spaceX, spaceY, spaceRight, spaceLeft, spaceTop, spaceBottom, children, }: BleedProps): react_jsx_runtime.JSX.Element;

type Align = "left" | "center" | "right";
type ResponsiveAlign = OptionalResponsiveValue<Align>;
type AlignY = "top" | "center" | "bottom" | "stretch" | "baseline";
type ResponsiveAlignY = OptionalResponsiveValue<AlignY>;
declare const alignToFlexAlignLookup: {
    readonly left: "flexStart";
    readonly center: "center";
    readonly right: "flexEnd";
};
declare const alignToFlexAlign: (align: OptionalResponsiveValue<Align> | undefined) => "center" | "flexStart" | "flexEnd" | Partial<Record<"wide" | "desktop" | "tablet" | "mobile", "center" | "flexStart" | "flexEnd">> | undefined;
declare const alignYToFlexAlignLookup: {
    readonly top: "flexStart";
    readonly center: "center";
    readonly bottom: "flexEnd";
    readonly stretch: "stretch";
    readonly baseline: "baseline";
};
declare const alignYToFlexAlign: (alignY: OptionalResponsiveValue<AlignY> | undefined) => "center" | "baseline" | "stretch" | "flexStart" | "flexEnd" | Partial<Record<"wide" | "desktop" | "tablet" | "mobile", "center" | "baseline" | "stretch" | "flexStart" | "flexEnd">> | undefined;

declare const breakpoints: {
    wide: {};
    desktop: {
        "@media": string;
    };
    tablet: {
        "@media": string;
    };
    mobile: {
        "@media": string;
    };
};
type Breakpoint = keyof typeof breakpoints;

type CollapsibleAlignmentProps = {
    align?: ResponsiveAlign;
    alignY?: ResponsiveAlignY;
    collapseBelow?: Exclude<Breakpoint, "mobile">;
    reverse?: boolean | Partial<Record<Breakpoint, boolean>>;
};

declare const wideWidths: Record<"content" | "full" | "1/2" | "1/3" | "2/3" | "1/4" | "3/4" | "1/5" | "2/5" | "3/5" | "4/5", string>;

type ColumnProps = {
    children: Children;
    width?: OptionalResponsiveValue<keyof typeof wideWidths>;
    sticky?: {
        top: Props$M["top"];
    };
};
declare function Column({ children, width, sticky }: ColumnProps): react_jsx_runtime.JSX.Element;
type Props$q = {
    space: ResponsiveSpace;
    children: Children;
} & CollapsibleAlignmentProps;
declare function Columns({ space, children, align, alignY, collapseBelow, reverse }: Props$q): react_jsx_runtime.JSX.Element;

type InlineProps = {
    space: ResponsiveSpace;
    children: Children;
} & CollapsibleAlignmentProps & AsProp;
declare function Inline({ space, children, align, alignY, collapseBelow, reverse, ...boxProps }: InlineProps): react_jsx_runtime.JSX.Element;

type InsetProps = {
    children: ComponentProps<typeof Box>["children"];
} & ({
    space: ResponsiveSpace;
    spaceX?: never;
    spaceY?: never;
} | {
    space?: never;
    spaceX: ResponsiveSpace;
    spaceY?: ResponsiveSpace;
} | {
    space?: never;
    spaceX?: ResponsiveSpace;
    spaceY: ResponsiveSpace;
});
declare function Inset({ space, spaceX, spaceY, children }: InsetProps): react_jsx_runtime.JSX.Element;

type StackProps = {
    space: ResponsiveSpace;
    children: Children;
    align?: ResponsiveAlign;
    dividers?: boolean;
} & AsProp;
declare function Stack({ space, align, children, dividers, ...boxProps }: StackProps): react_jsx_runtime.JSX.Element;

type Props$p = {
    space: ResponsiveSpace;
    columns: RequiredResponsiveValue<1 | 2 | 3 | 4 | 5 | 6 | 7>;
    children: Children;
    alignY?: ResponsiveAlignY;
};
declare function Tiles({ space, columns, alignY, children }: Props$p): react_jsx_runtime.JSX.Element;

type NestedMenuItemProps = Kind & LeftItem & CommonItemProps & {
    items: MenuItemProps[];
    trailingIcon?: never;
    onPress?: never;
    href?: never;
    target?: never;
};
type MenuItemProps = NestedMenuItemProps | (ListItemProps & {
    items?: never;
});
type MenuProps = {
    size: Props$Q["size"];
    items: MenuItemProps[];
    header?: Children;
    trigger: (ref: Ref<HTMLElement>, props: Pick<AriaButtonProps, "id" | "aria-labelledby">, state: MenuTriggerState) => JSX.Element;
    initialIsOpen?: boolean;
    placement?: ComponentProps<typeof Popover>["placement"];
    offset?: ComponentProps<typeof Popover>["offset"];
    dividers?: boolean;
    maxHeight?: number;
    closeOnSelect?: boolean;
    nestedMenuPlacement?: ComponentProps<typeof Popover>["placement"];
    nestedMenuOffset?: ComponentProps<typeof Popover>["offset"];
};

declare function Menu({ items, header, trigger, initialIsOpen, placement, offset, size, dividers, maxHeight, closeOnSelect, nestedMenuPlacement, nestedMenuOffset: _nestedMenuOffset, }: MenuProps): react_jsx_runtime.JSX.Element;

type BaseNumberProps = {
    placeholder?: LocalizedString;
    isReadOnly?: boolean;
    rightAccessory?: Children;
};
type FormatProps = {
    kind: "currency";
    currency: string;
} | {
    kind: "percentage";
} | {
    kind?: "decimal";
};

type Props$o = BaseNumberProps & {
    inputProps: React.InputHTMLAttributes<HTMLInputElement>;
    inputRef: React.Ref<HTMLInputElement>;
    numberValue: number;
    validationState: "valid" | "invalid";
    disabled?: boolean;
    name?: string;
} & FormatProps;
declare function BaseNumberInput(props: Props$o): react_jsx_runtime.JSX.Element;

type Props$n = FieldProps<number | undefined, number> & BaseNumberProps & FormatProps & Pick<NumberFieldStateOptions, "minValue" | "maxValue" | "step" | "formatOptions">;
declare function NumberField(props: Props$n): react_jsx_runtime.JSX.Element;

type Props$m = AtLeast<Pick<HTMLAttributes<HTMLInputElement>, "aria-label" | "aria-labelledby">> & Pick<FieldProps<number | undefined, number>, "autoFocus" | "disabled" | "name" | "onBlur" | "onChange" | "value"> & BaseNumberProps & {
    validationState?: "valid" | "invalid";
} & FormatProps & Pick<NumberFieldStateOptions, "minValue" | "maxValue" | "step" | "formatOptions">;
declare function NumberInput(props: Props$m): react_jsx_runtime.JSX.Element;

type PaginationMessages = {
    itemsPerPageOptionsLabel: LocalizedString;
    currentPageItemsLabel: (start: number, end: number, total: number) => LocalizedString;
    pageCountLabel: (pageCount: number) => LocalizedString;
    singlePageLabel: LocalizedString;
    previousPageButtonLabel: LocalizedString;
    nextPageButtonLabel: LocalizedString;
};
type ItemsPerPageOption = PaginationItemsPerPage[number];
type Props$l = {
    page: number;
    pageCount: number;
    itemsPerPage: ItemsPerPageOption;
    itemsPerPageOptions: Record<ItemsPerPageOption, LocalizedString>;
    onPageChange: (page: number) => void;
    onItemsPerPageChange: (itemsPerPage: ItemsPerPageOption) => void;
    messages: PaginationMessages;
};

declare function Pagination(props: Props$l): react_jsx_runtime.JSX.Element;

type Props$k = {
    height?: string | number;
    width?: string | number;
    label?: string;
    background?: BentoSprinkles["background"];
};
declare function Placeholder({ label, height, width, background }: Props$k): react_jsx_runtime.JSX.Element;

type Props$j = {
    children: Children;
    onClose: () => void;
    triggerRef: RefObject<HTMLElement>;
    placement?: Placement;
    offset?: number;
};
declare const Popover: react.ForwardRefExoticComponent<Props$j & react.RefAttributes<HTMLElement>>;

type Props$i = {
    label?: LocalizedString;
    kind: "continuous" | "discrete";
    value: number;
    maxValue: number;
};
declare function ProgressBar(props: Props$i): react_jsx_runtime.JSX.Element;

type RadioOption<A> = {
    value: A;
    label: LocalizedString;
    isDisabled?: boolean;
};
type Props$h<A> = FieldProps<A | undefined, A> & {
    name: string;
    options: Array<RadioOption<A>>;
    orientation?: "vertical" | "horizontal";
};
declare function RadioGroupField<A extends string | number | boolean>(props: Props$h<A>): react_jsx_runtime.JSX.Element;

type Props$g = FieldProps<string> & {
    placeholder?: LocalizedString;
    isReadOnly?: boolean;
    type?: "text" | "email" | "url" | "password";
    rightAccessory?: Children;
    showPasswordLabel?: never;
    hidePasswordLabel?: never;
} & Pick<React.HTMLProps<HTMLInputElement>, "onKeyDown" | "onKeyUp">;
declare function TextField(props: Props$g): react_jsx_runtime.JSX.Element;

type Props$f = Omit$1<Props$g, "onChange" | "onBlur" | "disabled" | "isReadOnly" | "placeholder" | "issues"> & (({
    withCopyButton: true;
    copyButtonLabel: LocalizedString;
} & ({
    copySuccessMessage: LocalizedString;
    showToastOnCopy: true;
} | {
    showToastOnCopy?: false;
})) | {
    withCopyButton?: false;
});
declare function ReadOnlyField(props: Props$f): react_jsx_runtime.JSX.Element;

type Props$e = AtLeast<Pick<HTMLAttributes<HTMLInputElement>, "aria-label" | "aria-labelledby">> & {
    value: string;
    onChange: (value: string) => unknown;
    onBlur?: () => unknown;
    placeholder?: LocalizedString;
    disabled?: boolean;
    clearButtonLabel?: LocalizedString;
    autoFocus?: boolean;
};
declare function SearchBar(props: Props$e): react_jsx_runtime.JSX.Element;

type MultiProps$1<A> = BaseMultiProps & Pick<FieldProps<A[]>, "autoFocus" | "disabled" | "name" | "onBlur" | "onChange" | "value">;
type SingleProps$1<A> = BaseSingleProps & Pick<FieldProps<A | undefined>, "autoFocus" | "disabled" | "name" | "onBlur" | "onChange" | "value">;
type Props$d<A> = BaseSelectProps<A> & {
    fieldProps: AriaLabelingProps & DOMProps;
    validationState: "valid" | "invalid";
} & (SingleProps$1<A> | MultiProps$1<A>);
declare function BaseSelect<A>(props: Props$d<A>): react_jsx_runtime.JSX.Element;

type MultiProps<A> = BaseMultiProps & Pick<FieldProps<A[]>, "autoFocus" | "disabled" | "name" | "onBlur" | "onChange" | "value">;
type SingleProps<A> = BaseSingleProps & Pick<FieldProps<A | undefined>, "autoFocus" | "disabled" | "name" | "onBlur" | "onChange" | "value">;
type Props$c<A> = AtLeast<Pick<HTMLAttributes<HTMLInputElement>, "aria-label" | "aria-labelledby">> & BaseSelectProps<A> & {
    validationState: "valid" | "invalid";
} & (SingleProps<A> | MultiProps<A>);
declare function SelectInput<A>(props: Props$c<A>): react_jsx_runtime.JSX.Element;

type Props$b = {
    type: "single" | "double";
    disabled?: boolean;
    trackRef: RefObject<HTMLDivElement>;
    state: SliderState;
    groupProps: DOMAttributes<FocusableElement>;
    trackProps: DOMAttributes<FocusableElement>;
    outputProps: OutputHTMLAttributes<HTMLOutputElement>;
    numberFormatter: Intl.NumberFormat;
    hideThumbValue?: boolean;
    autoFocus?: boolean;
};
declare function Slider(props: Props$b): react_jsx_runtime.JSX.Element;

type Props$a = (({
    type: "single";
    onChangeEnd?: (value: number) => void;
} & FieldProps<number>) | ({
    type: "double";
    onChangeEnd?: (value: [number, number]) => void;
} & FieldProps<[number, number]>)) & {
    minValue: number;
    maxValue: number;
    step?: number;
    dragStep?: number;
    hideThumbValue?: boolean;
} & FormatProps;
declare function SliderField(props: Props$a): react_jsx_runtime.JSX.Element;

type Step = {
    label: Children;
    key?: string | number;
};
type Props$9 = {
    currentStep: number;
    steps: Array<Step>;
};
type StepStatus = "todo" | "inProgress" | "done";

declare function Stepper({ currentStep, steps }: Props$9): react_jsx_runtime.JSX.Element;
declare function StepperStep({ label, index, status, }: {
    label: Children;
    index: number;
    status: StepStatus;
}): react_jsx_runtime.JSX.Element;

type Props$8 = Omit<FieldProps<boolean>, "assistiveText"> & {
    label: Children;
    switchPosition?: "leading" | "trailing";
};
declare function Switch(props: Props$8): react_jsx_runtime.JSX.Element;

type ColumnOptionsBase<A> = {
    accessor: A;
    headerLabel?: LocalizedString;
    missingValue?: LocalizedString;
    width?: Column$1<any>["gridWidth"];
} & Omit<Column$1<any>, "accessor" | "Header" | "Cell" | "sortType" | "width" | "gridWidth">;
declare function custom<A extends string, V, D extends Record<string, unknown>>({ headerLabel, sortType, missingValue, width, footer, ...options }: ColumnOptionsBase<A> & {
    Cell: (props: CellProps$1<D, V>) => Children;
    sortType?: (valueA: V | undefined, valueB: V | undefined) => number;
}): Column$2<A, D, V>;
declare function button<A extends string>({ size, ...options }: ColumnOptionsBase<A> & Partial<Pick<Props$O, "size">>): Column$2<A, any, Omit<Props$O, "size">>;
declare function buttonLink<A extends string>({ size, ...options }: ColumnOptionsBase<A> & Partial<Pick<Props$O, "size">>): Column$2<A, any, Omit<Props$R, "size">>;
declare function chip<A extends string>(options: ColumnOptionsBase<A>): Column$2<A, any, Props$S>;
declare function text<A extends string>({ size, weight, color, ...options }: ColumnOptionsBase<A> & Partial<Pick<Props$T, "size" | "weight" | "color">>): Column$2<A, any, string | ({
    text: string;
} & Partial<Pick<Props$T, "size" | "color" | "weight" | "align">>)>;
declare function textWithIcon<A extends string>({ iconPosition, iconSize, iconColor, size, weight, color, ...options }: ColumnOptionsBase<A> & {
    iconPosition: "left" | "right";
    iconSize?: IconProps["size"];
    iconColor?: IconProps["color"];
} & Partial<Pick<Props$T, "size" | "weight" | "color">>): Column$2<A, any, {
    icon: ((props: IconProps) => Children) | null;
    text: LocalizedString;
    tooltipContent?: Children;
} & Partial<Pick<Props$T, "size" | "color" | "weight">>>;
type NumberCellValue = number | ({
    numericValue: number;
} & Partial<Pick<Props$T, "size" | "weight" | "color" | "align">>);
declare function number<A extends string>({ valueFormatter, size, weight, color, ...options }: ColumnOptionsBase<A> & {
    valueFormatter: (n: number) => LocalizedString;
} & Partial<Pick<Props$T, "size" | "weight" | "color">>): Column$2<A, any, NumberCellValue>;
declare function numberWithIcon<A extends string>({ valueFormatter, size, weight, color, ...options }: ColumnOptionsBase<A> & {
    valueFormatter: (n: number) => LocalizedString;
} & Partial<Pick<Props$T, "size" | "weight" | "color">>): Column$2<A, any, {
    icon: ((props: IconProps) => Children) | null;
    numericValue: number;
    tooltipContent?: Children;
} & Partial<Pick<Props$T, "size" | "color" | "weight">>>;
declare function label<A extends string>({ size, color, ...options }: ColumnOptionsBase<A> & Partial<Pick<LabelProps, "size" | "color">>): Column$2<A, any, string | ({
    text: string;
} & Partial<Pick<LabelProps, "size" | "color" | "align">>)>;
declare function link<A extends string>({ size, weight, ...options }: ColumnOptionsBase<A> & Partial<Pick<Props$T, "size" | "weight">>): Column$2<A, any, {
    isDisabled?: boolean | undefined;
    active?: boolean | undefined;
    kind?: "default" | "inverse" | undefined;
    label?: string | undefined;
    children?: Children;
} & Omit<react.AnchorHTMLAttributes<HTMLAnchorElement>, "color">>;
declare function icon<A extends string>({ size, color, ...options }: ColumnOptionsBase<A> & Partial<Pick<IconProps, "size" | "color">>): Column$2<A, any, {
    icon: (props: IconProps) => JSX.Element;
    label: string;
}>;
declare function iconButton<A extends string>({ size, kind, hierarchy, ...options }: ColumnOptionsBase<A> & Partial<Pick<Props$U, "size" | "kind" | "hierarchy">>): Column$2<A, any, Omit<Props$U, "size" | "kind" | "hierarchy">>;

type tableColumn_ColumnOptionsBase<A> = ColumnOptionsBase<A>;
declare const tableColumn_button: typeof button;
declare const tableColumn_buttonLink: typeof buttonLink;
declare const tableColumn_chip: typeof chip;
declare const tableColumn_custom: typeof custom;
declare const tableColumn_icon: typeof icon;
declare const tableColumn_iconButton: typeof iconButton;
declare const tableColumn_label: typeof label;
declare const tableColumn_link: typeof link;
declare const tableColumn_number: typeof number;
declare const tableColumn_numberWithIcon: typeof numberWithIcon;
declare const tableColumn_text: typeof text;
declare const tableColumn_textWithIcon: typeof textWithIcon;
declare namespace tableColumn {
  export {
    CellProps$1 as CellProps,
    tableColumn_ColumnOptionsBase as ColumnOptionsBase,
    tableColumn_button as button,
    tableColumn_buttonLink as buttonLink,
    tableColumn_chip as chip,
    tableColumn_custom as custom,
    tableColumn_icon as icon,
    tableColumn_iconButton as iconButton,
    tableColumn_label as label,
    tableColumn_link as link,
    tableColumn_number as number,
    tableColumn_numberWithIcon as numberWithIcon,
    tableColumn_text as text,
    tableColumn_textWithIcon as textWithIcon,
  };
}

type SortFn<C extends ReadonlyArray<Column$2<string, any, any>> | ReadonlyArray<GroupedColumn<string, any, any>>> = (a: Row$1<Row<C>>, b: Row$1<Row<C>>) => number;
type SortingProps<C extends ReadonlyArray<Column$2<string, any, any>> | ReadonlyArray<GroupedColumn<string, any, any>>> = {
    customSorting?: never;
    onSort?: (sortBy: Array<SortingRule<C>>) => void;
} | {
    customSorting: (rows: Row$1<Row<C>>[], sortFns: SortFn<C>[]) => Row$1<Row<C>>[];
    onSort?: never;
};
type Props$7<C extends ReadonlyArray<Column$2<string, any, any>> | ReadonlyArray<GroupedColumn<string, any, any>>> = {
    columns: C;
    data: ReadonlyArray<Row<C>>;
    groupBy?: C extends ReadonlyArray<Column$2<string, any, any>> ? C[number]["accessor"] : C extends ReadonlyArray<GroupedColumn<string, any, any>> ? C[number]["columns"][number]["accessor"] : never;
    noResultsTitle?: LocalizedString;
    noResultsDescription?: LocalizedString;
    noResultsFeedbackSize?: Props$V["size"];
    initialSorting?