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

The buildo DS

import { I as IconProps, a as IllustrationProps, b as IllustrationColor, L as LocalizedString, A as ActionsConfig, c as AreaLoaderConfig, d as AvatarConfig, B as BannerConfig, e as BreadcrumbConfig, f as ButtonConfig, C as CardConfig, g as ChartConfig, h as ChipConfig, D as DecorativeDividerConfig, i as DisclosureConfig, j as DisclosureGroupConfig, F as FeedbackConfig, k as FieldConfig, l as FileUploaderFieldConfig, m as InlineLoaderConfig, n as InputConfig, S as SelectionControlGroupConfig, o as SelectionControlConfig, p as FormLayoutConfig, q as IconButtonConfig, r as ListConfig, M as MenuConfig, s as ModalConfig, N as NavigationConfig, R as ReadOnlyFieldConfig, t as SearchBarConfig, u as DropdownConfig, T as TableConfig, v as ToastConfig, w as TabsConfig, P as ProgressBarConfig, x as SliderConfig, y as StepperConfig, z as TooltipConfig, E as DateFieldConfig, G as Props$J, H as Children, J as BentoSprinkles, K as ChartDataColor, O as Omit$1, Q as AtLeast, U as FieldProps, V as RequiredResponsiveValue, W as Props$K, X as Props$L, Y as NonEmptyArray, Z as Props$M, _ as ResponsiveSpace, $ as OptionalResponsiveValue, a0 as AsProp, a1 as Box, a2 as Kind, a3 as LeftItem, a4 as CommonItemProps, a5 as ListItemProps, a6 as Props$N, a7 as Column$2, a8 as Props$O, a9 as Props$P, aa as Row, ab as Props$Q, ac as TooltipPlacement, ad as DefaultMessages, ae as PartialBentoConfig, af as bentoSprinkles, ag as SprinklesFn, ah as Actions, ai as Banner, aj as Body, ak as BoxType, al as Button, am as Chip, an as CustomModal, ao as LinkComponentProps, ap as PartialDeep, aq as BentoConfig, ar as Disclosure, as as Display, at as Feedback, au as Headline, av as Label, aw as List, ax as ListSize, ay as Modal, az as Navigation, aA as SelectField, aB as Tabs, aC as Title } from './BentoConfig-70376dba.js';
export { ah as Actions, Z as ActionsProps, a0 as AsProp, ai as Banner, aF as BannerProps, aq as BentoConfig, aI as BentoProvider, aj as Body, a9 as BodyProps, a1 as Box, W as BoxProps, ak as BoxType, al as Button, G as ButtonProps, aL as ButtonSize, g as ChartConfig, K as ChartDataColor, H as Children, am as Chip, aE as ChipCustomColors, a8 as ChipProps, a7 as ColumnType, a4 as CommonItemProps, b0 as ConfiguredTypes, aE as CustomChipColors, an as CustomModal, b7 as DefaultLinkComponent, aJ as DesignSystemProvider, ar as Disclosure, X as DisclosureProps, as as Display, aY as DisplayProps, at as Feedback, ab as FeedbackProps, aM as FeedbackSize, U as FieldProps, au as Headline, aZ as HeadlineProps, I as IconProps, b as IllustrationColor, a as IllustrationProps, aG as Kind, av as Label, a_ as LabelProps, b6 as LinkComponent, b8 as LinkComponentContext, ao as LinkComponentProps, aw as List, aO as ListItem, a2 as ListItemKind, a5 as ListItemProps, a3 as ListLeftItem, a6 as ListProps, aN as ListRightItem, ax as ListSize, L as LocalizedString, ay as Modal, aR as ModalKind, aP as ModalProps, aQ as ModalSize, az as Navigation, aS as NavigationProps, aT as NavigationSize, Y as NonEmptyArray, O as Omit, aK as OtherButtonKeys, ae as PartialBentoConfig, aa as RowType, aA as SelectField, aU as SelectFieldProps, aV as SelectOption, ag as SprinklesFn, aB as Tabs, aW as TabsProps, aX as TabsSize, aC as Title, a$ as TitleProps, aD as TypeOverrides, b3 as allColors, af as bentoSprinkles, aH as createBentoProvider, b5 as makeLinkComponent, b2 as responsiveProperties, b4 as statusProperties, b1 as unconditionalProperties, b9 as useLinkComponent, ba as vars } from './BentoConfig-70376dba.js';
import * as react from 'react';
import { AnchorHTMLAttributes, ReactElement, HTMLAttributes, ComponentProps, ElementType, LabelHTMLAttributes, DOMAttributes, SVGProps, SVGAttributes, Ref, RefObject, OutputHTMLAttributes, FunctionComponent } from 'react';
import { ResponsiveContainerProps, TooltipProps, LegendProps, BarProps, LineProps, PieProps, CellProps } from 'recharts';
import * as _vanilla_extract_private from '@vanilla-extract/private';
import { CSSVarFunction } from '@vanilla-extract/private';
import { Payload } from 'recharts/types/component/DefaultLegendContent';
import { UseDatepickerProps } from '@datepicker-react/hooks';
import { FocusableElement } from '@react-types/shared';
import { ErrorCode as ErrorCode$1 } from 'react-dropzone';
import { AriaButtonProps } from '@react-types/button';
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 { Time } from '@internationalized/date';
import * as _vanilla_extract_sprinkles_dist_declarations_src_createSprinkles from '@vanilla-extract/sprinkles/dist/declarations/src/createSprinkles';
import { SprinklesProperties } from '@vanilla-extract/sprinkles/dist/declarations/src/types';
import { VariantGroups, PatternOptions } from '@vanilla-extract/recipes/dist/declarations/src/types';
export { ClassValue } from 'clsx';
export { SSRProvider, SSRProviderProps } from '@react-aria/ssr';
import '@vanilla-extract/sprinkles';
import 'react-select';

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

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

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

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

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

declare function IconClose(props: IconProps): JSX.Element;

declare function IconCopyLight(props: IconProps): JSX.Element;

declare function IconEdit(props: IconProps): JSX.Element;

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

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

declare function IconHelp(props: IconProps): JSX.Element;

declare function IconIdea(props: IconProps): JSX.Element;

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

declare function IconInformative(props: IconProps): JSX.Element;

declare function IconMenu(props: IconProps): JSX.Element;

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

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

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

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

declare function IconPositive(props: IconProps): JSX.Element;

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

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

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

declare function IconWarning(props: IconProps): JSX.Element;

declare const index$1_IconCheck: typeof IconCheck;
declare const index$1_IconChevronDown: typeof IconChevronDown;
declare const index$1_IconChevronLeft: typeof IconChevronLeft;
declare const index$1_IconChevronRight: typeof IconChevronRight;
declare const index$1_IconChevronUp: typeof IconChevronUp;
declare const index$1_IconClose: typeof IconClose;
declare const index$1_IconCopyLight: typeof IconCopyLight;
declare const index$1_IconEdit: typeof IconEdit;
declare const index$1_IconEye: typeof IconEye;
declare const index$1_IconEyeClosed: typeof IconEyeClosed;
declare const index$1_IconHelp: typeof IconHelp;
declare const index$1_IconIdea: typeof IconIdea;
declare const index$1_IconInfo: typeof IconInfo;
declare const index$1_IconInformative: typeof IconInformative;
declare const index$1_IconMenu: typeof IconMenu;
declare const index$1_IconMinus: typeof IconMinus;
declare const index$1_IconNegative: typeof IconNegative;
declare const index$1_IconPlaceholder: typeof IconPlaceholder;
declare const index$1_IconPlus: typeof IconPlus;
declare const index$1_IconPositive: typeof IconPositive;
declare const index$1_IconProps: typeof IconProps;
declare const index$1_IconSearch: typeof IconSearch;
declare const index$1_IconSpinner: typeof IconSpinner;
declare const index$1_IconUser: typeof IconUser;
declare const index$1_IconWarning: typeof IconWarning;
declare namespace index$1 {
  export {
    index$1_IconCheck as IconCheck,
    index$1_IconChevronDown as IconChevronDown,
    index$1_IconChevronLeft as IconChevronLeft,
    index$1_IconChevronRight as IconChevronRight,
    index$1_IconChevronUp as IconChevronUp,
    index$1_IconClose as IconClose,
    index$1_IconCopyLight as IconCopyLight,
    index$1_IconEdit as IconEdit,
    index$1_IconEye as IconEye,
    index$1_IconEyeClosed as IconEyeClosed,
    index$1_IconHelp as IconHelp,
    index$1_IconIdea as IconIdea,
    index$1_IconInfo as IconInfo,
    index$1_IconInformative as IconInformative,
    index$1_IconMenu as IconMenu,
    index$1_IconMinus as IconMinus,
    index$1_IconNegative as IconNegative,
    index$1_IconPlaceholder as IconPlaceholder,
    index$1_IconPlus as IconPlus,
    index$1_IconPositive as IconPositive,
    index$1_IconProps as IconProps,
    index$1_IconSearch as IconSearch,
    index$1_IconSpinner as IconSpinner,
    index$1_IconUser as IconUser,
    index$1_IconWarning as IconWarning,
  };
}

declare function IllustrationAddress(props: IllustrationProps): JSX.Element;

declare function IllustrationBarChart(props: IllustrationProps): JSX.Element;

declare function IllustrationBinder(props: IllustrationProps): JSX.Element;

declare function IllustrationBook(props: IllustrationProps): JSX.Element;

declare function IllustrationBriefcase(props: IllustrationProps): JSX.Element;

declare function IllustrationCalendar(props: IllustrationProps): JSX.Element;

declare function IllustrationCalendarEnd(props: IllustrationProps): JSX.Element;

declare function IllustrationCalendarStart(props: IllustrationProps): JSX.Element;

declare function IllustrationChart(props: IllustrationProps): JSX.Element;

declare function IllustrationClick(props: IllustrationProps): JSX.Element;

declare function IllustrationCoin(props: IllustrationProps): JSX.Element;

declare function IllustrationCoinInHand(props: IllustrationProps): JSX.Element;

declare function IllustrationCoins(props: IllustrationProps): JSX.Element;

declare function IllustrationCoinsStack(props: IllustrationProps): JSX.Element;

declare function IllustrationCommunication(props: IllustrationProps): JSX.Element;

declare function IllustrationCreditCard(props: IllustrationProps): JSX.Element;

declare function IllustrationDashboard(props: IllustrationProps): JSX.Element;

declare function IllustrationDatabase(props: IllustrationProps): JSX.Element;

declare function IllustrationDesktop(props: IllustrationProps): JSX.Element;

declare function IllustrationDocuments(props: IllustrationProps): JSX.Element;

declare function IllustrationDonation(props: IllustrationProps): JSX.Element;

declare function IllustrationDonutChart(props: IllustrationProps): JSX.Element;

declare function IllustrationError(props: IllustrationProps): JSX.Element;

declare function IllustrationFolder(props: IllustrationProps): JSX.Element;

declare function IllustrationGear(props: IllustrationProps): JSX.Element;

declare function IllustrationGrowingMoney(props: IllustrationProps): JSX.Element;

declare function IllustrationGuarantee(props: IllustrationProps): JSX.Element;

declare function IllustrationHandshake(props: IllustrationProps): JSX.Element;

declare function IllustrationHeart(props: IllustrationProps): JSX.Element;

declare function IllustrationID(props: IllustrationProps): JSX.Element;

declare function IllustrationIdea(props: IllustrationProps): JSX.Element;

declare function IllustrationJobSearch(props: IllustrationProps): JSX.Element;

declare function IllustrationKey(props: IllustrationProps): JSX.Element;

declare function IllustrationLaptop(props: IllustrationProps): JSX.Element;

declare function IllustrationLaptopClick(props: IllustrationProps): JSX.Element;

declare function IllustrationLike(props: IllustrationProps): JSX.Element;

declare function IllustrationLineChart(props: IllustrationProps): JSX.Element;

declare function IllustrationMail(props: IllustrationProps): JSX.Element;

declare function IllustrationMap(props: IllustrationProps): JSX.Element;

declare function IllustrationMegaphone(props: IllustrationProps): JSX.Element;

declare function IllustrationMission(props: IllustrationProps): JSX.Element;

declare function IllustrationMouse(props: IllustrationProps): JSX.Element;

declare function IllustrationNegative(props: IllustrationProps): JSX.Element;

declare function IllustrationNewJob(props: IllustrationProps): JSX.Element;

declare function IllustrationNotification(props: IllustrationProps): JSX.Element;

declare function IllustrationPencil(props: IllustrationProps): JSX.Element;

declare function IllustrationPieChart(props: IllustrationProps): JSX.Element;

declare function IllustrationPiggy(props: IllustrationProps): JSX.Element;

declare function IllustrationPiggyCoins(props: IllustrationProps): JSX.Element;

declare function IllustrationPositive(props: IllustrationProps): JSX.Element;

declare function IllustrationProfile(props: IllustrationProps): JSX.Element;

declare function IllustrationResume(props: IllustrationProps): JSX.Element;

declare function IllustrationSales(props: IllustrationProps): JSX.Element;

declare function IllustrationScatterPlot(props: IllustrationProps): JSX.Element;

declare function IllustrationSearch(props: IllustrationProps): JSX.Element;

declare function IllustrationSmartphone(props: IllustrationProps): JSX.Element;

declare function IllustrationStar(props: IllustrationProps): JSX.Element;

declare function IllustrationStocks(props: IllustrationProps): JSX.Element;

declare function IllustrationTablet(props: IllustrationProps): JSX.Element;

declare function IllustrationTarget(props: IllustrationProps): JSX.Element;

declare function IllustrationTaskCompleted(props: IllustrationProps): JSX.Element;

declare function IllustrationTouch(props: IllustrationProps): JSX.Element;

declare function IllustrationTrash(props: IllustrationProps): JSX.Element;

declare const index_IllustrationAddress: typeof IllustrationAddress;
declare const index_IllustrationBarChart: typeof IllustrationBarChart;
declare const index_IllustrationBinder: typeof IllustrationBinder;
declare const index_IllustrationBook: typeof IllustrationBook;
declare const index_IllustrationBriefcase: typeof IllustrationBriefcase;
declare const index_IllustrationCalendar: typeof IllustrationCalendar;
declare const index_IllustrationCalendarEnd: typeof IllustrationCalendarEnd;
declare const index_IllustrationCalendarStart: typeof IllustrationCalendarStart;
declare const index_IllustrationChart: typeof IllustrationChart;
declare const index_IllustrationClick: typeof IllustrationClick;
declare const index_IllustrationCoin: typeof IllustrationCoin;
declare const index_IllustrationCoinInHand: typeof IllustrationCoinInHand;
declare const index_IllustrationCoins: typeof IllustrationCoins;
declare const index_IllustrationCoinsStack: typeof IllustrationCoinsStack;
declare const index_IllustrationCommunication: typeof IllustrationCommunication;
declare const index_IllustrationCreditCard: typeof IllustrationCreditCard;
declare const index_IllustrationDashboard: typeof IllustrationDashboard;
declare const index_IllustrationDatabase: typeof IllustrationDatabase;
declare const index_IllustrationDesktop: typeof IllustrationDesktop;
declare const index_IllustrationDocuments: typeof IllustrationDocuments;
declare const index_IllustrationDonation: typeof IllustrationDonation;
declare const index_IllustrationDonutChart: typeof IllustrationDonutChart;
declare const index_IllustrationError: typeof IllustrationError;
declare const index_IllustrationFolder: typeof IllustrationFolder;
declare const index_IllustrationGear: typeof IllustrationGear;
declare const index_IllustrationGrowingMoney: typeof IllustrationGrowingMoney;
declare const index_IllustrationGuarantee: typeof IllustrationGuarantee;
declare const index_IllustrationHandshake: typeof IllustrationHandshake;
declare const index_IllustrationHeart: typeof IllustrationHeart;
declare const index_IllustrationID: typeof IllustrationID;
declare const index_IllustrationIdea: typeof IllustrationIdea;
declare const index_IllustrationJobSearch: typeof IllustrationJobSearch;
declare const index_IllustrationKey: typeof IllustrationKey;
declare const index_IllustrationLaptop: typeof IllustrationLaptop;
declare const index_IllustrationLaptopClick: typeof IllustrationLaptopClick;
declare const index_IllustrationLike: typeof IllustrationLike;
declare const index_IllustrationLineChart: typeof IllustrationLineChart;
declare const index_IllustrationMail: typeof IllustrationMail;
declare const index_IllustrationMap: typeof IllustrationMap;
declare const index_IllustrationMegaphone: typeof IllustrationMegaphone;
declare const index_IllustrationMission: typeof IllustrationMission;
declare const index_IllustrationMouse: typeof IllustrationMouse;
declare const index_IllustrationNegative: typeof IllustrationNegative;
declare const index_IllustrationNewJob: typeof IllustrationNewJob;
declare const index_IllustrationNotification: typeof IllustrationNotification;
declare const index_IllustrationPencil: typeof IllustrationPencil;
declare const index_IllustrationPieChart: typeof IllustrationPieChart;
declare const index_IllustrationPiggy: typeof IllustrationPiggy;
declare const index_IllustrationPiggyCoins: typeof IllustrationPiggyCoins;
declare const index_IllustrationPositive: typeof IllustrationPositive;
declare const index_IllustrationProfile: typeof IllustrationProfile;
declare const index_IllustrationColor: typeof IllustrationColor;
declare const index_IllustrationProps: typeof IllustrationProps;
declare const index_IllustrationResume: typeof IllustrationResume;
declare const index_IllustrationSales: typeof IllustrationSales;
declare const index_IllustrationScatterPlot: typeof IllustrationScatterPlot;
declare const index_IllustrationSearch: typeof IllustrationSearch;
declare const index_IllustrationSmartphone: typeof IllustrationSmartphone;
declare const index_IllustrationStar: typeof IllustrationStar;
declare const index_IllustrationStocks: typeof IllustrationStocks;
declare const index_IllustrationTablet: typeof IllustrationTablet;
declare const index_IllustrationTarget: typeof IllustrationTarget;
declare const index_IllustrationTaskCompleted: typeof IllustrationTaskCompleted;
declare const index_IllustrationTouch: typeof IllustrationTouch;
declare const index_IllustrationTrash: typeof IllustrationTrash;
declare namespace index {
  export {
    index_IllustrationAddress as IllustrationAddress,
    index_IllustrationBarChart as IllustrationBarChart,
    index_IllustrationBinder as IllustrationBinder,
    index_IllustrationBook as IllustrationBook,
    index_IllustrationBriefcase as IllustrationBriefcase,
    index_IllustrationCalendar as IllustrationCalendar,
    index_IllustrationCalendarEnd as IllustrationCalendarEnd,
    index_IllustrationCalendarStart as IllustrationCalendarStart,
    index_IllustrationChart as IllustrationChart,
    index_IllustrationClick as IllustrationClick,
    index_IllustrationCoin as IllustrationCoin,
    index_IllustrationCoinInHand as IllustrationCoinInHand,
    index_IllustrationCoins as IllustrationCoins,
    index_IllustrationCoinsStack as IllustrationCoinsStack,
    index_IllustrationCommunication as IllustrationCommunication,
    index_IllustrationCreditCard as IllustrationCreditCard,
    index_IllustrationDashboard as IllustrationDashboard,
    index_IllustrationDatabase as IllustrationDatabase,
    index_IllustrationDesktop as IllustrationDesktop,
    index_IllustrationDocuments as IllustrationDocuments,
    index_IllustrationDonation as IllustrationDonation,
    index_IllustrationDonutChart as IllustrationDonutChart,
    index_IllustrationError as IllustrationError,
    index_IllustrationFolder as IllustrationFolder,
    index_IllustrationGear as IllustrationGear,
    index_IllustrationGrowingMoney as IllustrationGrowingMoney,
    index_IllustrationGuarantee as IllustrationGuarantee,
    index_IllustrationHandshake as IllustrationHandshake,
    index_IllustrationHeart as IllustrationHeart,
    index_IllustrationID as IllustrationID,
    index_IllustrationIdea as IllustrationIdea,
    index_IllustrationJobSearch as IllustrationJobSearch,
    index_IllustrationKey as IllustrationKey,
    index_IllustrationLaptop as IllustrationLaptop,
    index_IllustrationLaptopClick as IllustrationLaptopClick,
    index_IllustrationLike as IllustrationLike,
    index_IllustrationLineChart as IllustrationLineChart,
    index_IllustrationMail as IllustrationMail,
    index_IllustrationMap as IllustrationMap,
    index_IllustrationMegaphone as IllustrationMegaphone,
    index_IllustrationMission as IllustrationMission,
    index_IllustrationMouse as IllustrationMouse,
    index_IllustrationNegative as IllustrationNegative,
    index_IllustrationNewJob as IllustrationNewJob,
    index_IllustrationNotification as IllustrationNotification,
    index_IllustrationPencil as IllustrationPencil,
    index_IllustrationPieChart as IllustrationPieChart,
    index_IllustrationPiggy as IllustrationPiggy,
    index_IllustrationPiggyCoins as IllustrationPiggyCoins,
    index_IllustrationPositive as IllustrationPositive,
    index_IllustrationProfile as IllustrationProfile,
    index_IllustrationColor as IllustrationColor,
    index_IllustrationProps as IllustrationProps,
    index_IllustrationResume as IllustrationResume,
    index_IllustrationSales as IllustrationSales,
    index_IllustrationScatterPlot as IllustrationScatterPlot,
    index_IllustrationSearch as IllustrationSearch,
    index_IllustrationSmartphone as IllustrationSmartphone,
    index_IllustrationStar as IllustrationStar,
    index_IllustrationStocks as IllustrationStocks,
    index_IllustrationTablet as IllustrationTablet,
    index_IllustrationTarget as IllustrationTarget,
    index_IllustrationTaskCompleted as IllustrationTaskCompleted,
    index_IllustrationTouch as IllustrationTouch,
    index_IllustrationTrash as IllustrationTrash,
  };
}

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

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 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_decorativeDivider: typeof decorativeDivider;
declare const defaultConfigs_disclosure: typeof disclosure;
declare const defaultConfigs_disclosureGroup: typeof disclosureGroup;
declare const defaultConfigs_feedback: typeof feedback;
declare const defaultConfigs_field: typeof field;
declare const defaultConfigs_fileUploaderField: typeof fileUploaderField;
declare const defaultConfigs_inlineLoader: typeof inlineLoader;
declare const defaultConfigs_input: typeof input;
declare const defaultConfigs_selectionControl: typeof selectionControl;
declare const defaultConfigs_formLayout: typeof formLayout;
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_readOnlyField: typeof readOnlyField;
declare const defaultConfigs_searchBar: typeof searchBar;
declare const defaultConfigs_dropdown: typeof dropdown;
declare const defaultConfigs_table: typeof table;
declare const defaultConfigs_toast: typeof toast;
declare const defaultConfigs_folderTabs: typeof folderTabs;
declare const defaultConfigs_underlineTabs: typeof underlineTabs;
declare const defaultConfigs_tabs: typeof tabs;
declare const defaultConfigs_progressBar: typeof progressBar;
declare const defaultConfigs_slider: typeof slider;
declare const defaultConfigs_stepper: typeof stepper;
declare const defaultConfigs_tooltip: typeof tooltip;
declare const defaultConfigs_dateField: typeof dateField;
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_decorativeDivider as decorativeDivider,
    defaultConfigs_disclosure as disclosure,
    defaultConfigs_disclosureGroup as disclosureGroup,
    defaultConfigs_feedback as feedback,
    defaultConfigs_field as field,
    defaultConfigs_fileUploaderField as fileUploaderField,
    defaultConfigs_inlineLoader as inlineLoader,
    defaultConfigs_input as input,
    defaultConfigs_selectionControl as selectionControl,
    defaultConfigs_formLayout as formLayout,
    iconButton$1 as iconButton,
    defaultConfigs_list as list,
    defaultConfigs_menu as menu,
    defaultConfigs_modal as modal,
    defaultConfigs_navigation as navigation,
    defaultConfigs_readOnlyField as readOnlyField,
    defaultConfigs_searchBar as searchBar,
    defaultConfigs_dropdown as dropdown,
    defaultConfigs_table as table,
    defaultConfigs_toast as toast,
    defaultConfigs_folderTabs as folderTabs,
    defaultConfigs_underlineTabs as underlineTabs,
    defaultConfigs_tabs as tabs,
    defaultConfigs_progressBar as progressBar,
    defaultConfigs_slider as slider,
    defaultConfigs_stepper as stepper,
    defaultConfigs_tooltip as tooltip,
    defaultConfigs_dateField as dateField,
  };
}

declare type Props$I = {
    message?: LocalizedString;
};

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

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

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

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

declare type Props$F = {
    href: string;
    label: Props$J["label"];
    kind: Props$J["kind"];
    hierarchy: Props$J["hierarchy"];
    isDisabled?: Props$J["isDisabled"];
    size?: Props$J["size"];
    active?: boolean;
    icon?: (props: IconProps) => JSX.Element;
    iconPosition?: "leading" | "trailing";
} & Omit<AnchorHTMLAttributes<HTMLAnchorElement>, "color">;
declare function ButtonLink({ href, target, kind, hierarchy, size: size_, isDisabled, label, active, icon, iconPosition, ...props }: Props$F): JSX.Element;

declare type PaddingKey = "padding" | "paddingX" | "paddingY" | "paddingLeft" | "paddingRight" | "paddingTop" | "paddingBottom";
declare type Props$E = {
    children: Children;
    elevation?: "small" | "medium" | "large";
    borderRadius?: Exclude<BentoSprinkles["borderRadius"], "circled">;
} & {
    [k in PaddingKey]?: 0 | BentoSprinkles["padding"];
};
declare function Card({ children, elevation, borderRadius, ...boxProps }: Props$E): JSX.Element;

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

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

declare type Props$D<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$D<D, C>): JSX.Element;

declare type Props$C<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$C<D, C>): JSX.Element;

declare type Props$B<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$B<D, C>): JSX.Element;

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

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

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

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

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

declare type ShortcutProps<Value> = {
    label: LocalizedString;
    value: Value;
};
declare type SingleDateFieldProps = {
    type?: "single";
    shortcuts?: ShortcutProps<Date>[];
} & FieldProps<Date | null>;
declare type RangeDateFieldProps = {
    type: "range";
    shortcuts?: ShortcutProps<[Date, Date]>[];
} & FieldProps<[Date | null, Date | null]>;
declare type Props$v = (SingleDateFieldProps | RangeDateFieldProps) & {
    minDate?: UseDatepickerProps["minBookingDate"];
    maxDate?: UseDatepickerProps["maxBookingDate"];
    readOnly?: boolean;
};
declare function DateField(props: Props$v): JSX.Element;

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

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

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

declare type Props$s = 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$s): JSX.Element;
declare type FieldType = React.FunctionComponent<Props$s>;

declare const errorCodes: readonly [ErrorCode$1.FileInvalidType, ErrorCode$1.FileTooLarge, ErrorCode$1.TooManyFiles];
declare type KnownDropzoneErrorCode = typeof errorCodes[number];
declare type ErrorCode = `${KnownDropzoneErrorCode}` | "generic-error" | "wrong-structure" | "unable-to-read";
declare type FileUploaderTexts = {
    title: LocalizedString;
    description: LocalizedString;
    uploadAgainMessage: LocalizedString;
    uploadingMessage: LocalizedString;
    uploadButtonLabel: LocalizedString;
    assistiveTextFileTypes: (allowedFileTypes?: Record<string, string[]>) => LocalizedString;
    assistiveTextMaxSize: (maxFileSizeMb?: number) => LocalizedString;
};
declare type FileResult<E extends string> = {
    readonly status: "valid";
    file: File;
} | {
    readonly status: "invalid";
    file: File;
    issues: NonEmptyArray<E | ErrorCode>;
};
declare type Props$r<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, }: Props$r<E>): JSX.Element;

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

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

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

declare type Props$n = {
    kind: "solid" | "transparent" | "outline";
    hierarchy: "primary" | "secondary" | "danger";
    label: LocalizedString;
    onPress: () => void;
    size: IconProps["size"];
    tabIndex?: number;
    isDisabled?: boolean;
    icon: (props: IconProps) => Children;
};
declare function IconButton(props: Props$n): JSX.Element;

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

declare function svgIllustrationProps(props: IllustrationProps): SVGAttributes<SVGElement>;

declare type Props$m = {
    message?: LocalizedString;
};

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

declare 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): JSX.Element;

declare type Align = "left" | "center" | "right";
declare type ResponsiveAlign = OptionalResponsiveValue<Align>;
declare type AlignY = "top" | "center" | "bottom" | "stretch" | "baseline";
declare 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) => "baseline" | "stretch" | "center" | "flexStart" | "flexEnd" | Partial<Record<"wide" | "desktop" | "tablet" | "mobile", "baseline" | "stretch" | "center" | "flexStart" | "flexEnd">> | undefined;

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

declare 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>;

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

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

declare 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): JSX.Element;

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

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

declare type Props$j = {
    isDisabled?: boolean;
    active?: boolean;
    kind?: "default" | "inverse";
    label?: LocalizedString;
    children?: Children;
} & Omit<AnchorHTMLAttributes<HTMLAnchorElement>, "color">;
declare function Link({ href, isDisabled, label, children, active, kind, ...props }: Props$j): JSX.Element;

declare type NestedMenuItemProps = Kind & LeftItem & CommonItemProps & {
    items: MenuItemProps[];
    trailingIcon?: never;
    onPress?: never;
    href?: never;
    target?: never;
};
declare type MenuItemProps = NestedMenuItemProps | (ListItemProps & {
    items?: never;
});
declare type MenuProps = {
    size: Props$N["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): JSX.Element;

declare type FormatProps = {
    kind: "currency";
    currency: string;
} | {
    kind: "percentage";
} | {
    kind?: "decimal";
};

declare type Props$i = FieldProps<number | undefined, number> & {
    placeholder: LocalizedString;
    isReadOnly?: boolean;
    rightAccessory?: Children;
} & FormatProps & Pick<NumberFieldStateOptions, "minValue" | "maxValue" | "step">;
declare function NumberField(props: Props$i): JSX.Element;

declare type Props$h = {
    inputProps: React.InputHTMLAttributes<HTMLInputElement>;
    inputRef: React.Ref<HTMLInputElement>;
    placeholder?: LocalizedString;
    validationState: "valid" | "invalid";
    disabled?: boolean;
    isReadOnly?: boolean;
    rightAccessory?: Children;
} & FormatProps;
declare function NumberInput(props: Props$h): JSX.Element;

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

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

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

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

declare type Props$c = 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$c): JSX.Element;

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

declare type Props$a = 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$a): JSX.Element;

declare type Props$9 = {
    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$9): JSX.Element;

declare type Props$8 = (({
    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$8): JSX.Element;

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

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

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

declare type ColumnOptionsBase<A> = {
    accessor: A;
    headerLabel?: LocalizedString;
    missingValue?: LocalizedString;
    width?: Column$1<{}>["gridWidth"];
} & Omit<Column$1<{}>, "accessor" | "Header" | "Cell" | "sortType" | "width" | "gridWidth">;
declare function custom<A extends string, V, D extends Record<string, unknown>>({ headerLabel, sortType, missingValue, width, ...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$J, "size">>): Column$2<A, {}, Omit<Props$J, "size">>;
declare function buttonLink<A extends string>({ size, ...options }: ColumnOptionsBase<A> & Partial<Pick<Props$J, "size">>): Column$2<A, {}, Omit<Props$F, "size">>;
declare function chip<A extends string>(options: ColumnOptionsBase<A>): Column$2<A, {}, Props$O>;
declare function text<A extends string>({ size, weight, color, ...options }: ColumnOptionsBase<A> & Partial<Pick<Props$P, "size" | "weight" | "color">>): Column$2<A, {}, string>;
declare function textWithIcon<A extends string>({ iconPosition, iconSize, iconColo