import { AsyncListData, AsyncListOptions, Autocomplete, AutocompleteContext, AutocompleteStateContext, BreadcrumbProps, BreadcrumbsProps, ButtonProps, CalendarCellProps, CalendarGridHeaderProps, CalendarGridProps, CalendarHeaderCellProps, CalendarProps as CalendarProps$1, CellProps, CheckboxButtonProps, CheckboxFieldProps, Collection, ColumnProps, ColumnResizerProps, DateFieldProps, DateInput as DateInput$1, DateInputProps, DatePickerProps, DateRangePickerProps, DateSegmentProps, DateValue, DateValue as DateValue$1, Dialog, DialogProps, DialogTrigger, DisclosurePanelProps, DisclosureProps, DragAndDropHooks, DragAndDropHooks as DragAndDropHooks$1, DragAndDropOptions, DragAndDropOptions as DragAndDropOptions$1, DropIndicatorProps, DropItem, DropTarget, FieldError, Focusable, GridLayout, Group as Group$1, GroupProps as GroupProps$1, Header, HeadingProps, Input, InputProps, Key, Key as Key$1, LabelProps, LinkProps, ListBoxItem, ListBoxItemProps, ListBoxProps, ListData, ListLayout, MenuItemProps, MenuItemProps as MenuItemProps$1, MenuProps, MenuProps as MenuProps$1, MenuSectionProps, MenuTrigger as MenuTrigger$1, ModalOverlayProps, NumberFieldProps, Popover as UnstyledPopover, PopoverProps, Pressable, PreviewTrigger, PreviewTriggerProps, ProgressBarProps, RadioButtonProps, RadioFieldProps, RadioGroupProps, RangeCalendarProps as RangeCalendarProps$1, ResizableTableContainerProps as ResizableTableContainerProps$1, RouterProvider, RowProps, SearchFieldProps, Select, SelectProps, SelectValue, Selection, SeparatorProps, Size, SliderFillRenderProps, SliderOutputProps, SliderProps, SliderThumbProps, SliderTrackProps, SliderTrackRenderProps, SortDescriptor, SortDirection, SwitchButtonProps, SwitchFieldProps, TabListProps, TabPanelProps, TabProps, TableBodyProps as TableBodyProps$1, TableFooterProps as TableFooterProps$1, TableHeaderProps as TableHeaderProps$1, TableLayout, TableLoadMoreItemProps as TableLoadMoreItemProps$1, TableProps as TableProps$1, TagGroupProps as TagGroupProps$1, TagListProps as TagListProps$1, TagProps as TagProps$1, TextAreaProps, TextDropItem, TextFieldProps, TextProps, TimeFieldProps, TimeValue, TimeValue as TimeValue$1, ToggleButtonGroupProps as ToggleButtonGroupProps$1, ToggleButtonProps, TokenFieldProps, TokenFieldValue, TokenFieldValue as TokenFieldValue$1, TokenInputProps as TokenInputProps$1, TokenProps as TokenProps$1, ToolbarProps as ToolbarProps$1, TreeItemContentProps as TreeItemContentProps$1, TreeItemProps as TreeItemProps$1, TreeLoadMoreItemProps as TreeLoadMoreItemProps$1, TreeProps as TreeProps$1, Virtualizer, VirtualizerProps, WaterfallLayout, isTextDropItem, useAsyncList, useDragAndDrop, useFilter, useListData } from "react-aria-components";
import React$1, { ComponentProps, JSX, Key as Key$2, ReactNode, Ref, TableHTMLAttributes } from "react";
import { ExternalToast, ToasterProps } from "sonner";
//#region src/components/breadcrumbs/breadcrumbs.d.ts
declare function Breadcrumbs<T extends object>({ className, ...props }: BreadcrumbsProps<T>): import("react").JSX.Element;
declare function Breadcrumb({ className, children, href, ...props }: BreadcrumbProps & {
  href?: string;
}): import("react").JSX.Element;
//#endregion
//#region src/components/button.d.ts
type ButtonShape = "round" | "square" | "normal";
type ButtonPreset = "primary" | "secondary" | "text" | "hextech" | "dimmed";
type ButtonSize = "small" | "medium" | "large";
interface ButtonProps$1 extends ButtonProps {
  preset?: ButtonPreset;
  thin?: boolean;
  shape?: ButtonShape;
  size?: ButtonSize;
}
declare const button: (props?: ({
  preset?: "primary" | "secondary" | "text" | "hextech" | "dimmed" | undefined;
  shape?: "round" | "square" | "normal" | undefined;
  thin?: boolean | undefined;
  size?: "small" | "medium" | "large" | undefined;
} & ({
  class?: import("cva").ClassValue;
  className?: never;
} | {
  class?: never;
  className?: import("cva").ClassValue;
})) | undefined) => string;
declare function Button({ children, className, preset, shape, size, thin, ref, ...props }: ButtonProps$1 & {
  ref?: Ref<HTMLButtonElement>;
}): import("react").JSX.Element;
//#endregion
//#region src/components/button-link.d.ts
interface ButtonLinkProps extends LinkProps {
  preset?: ButtonPreset;
  thin?: boolean;
  shape?: ButtonShape;
  size?: ButtonSize;
}
declare function ButtonLink({ children, className, preset, shape, size, ref, thin, ...props }: ButtonLinkProps & {
  ref?: Ref<HTMLAnchorElement>;
}): import("react").JSX.Element;
//#endregion
//#region src/components/calendar/calendar.d.ts
declare function CalendarHeaderCell({ className, ...props }: CalendarHeaderCellProps): import("react").JSX.Element;
declare function CalendarGridHeader({ className, ...props }: CalendarGridHeaderProps): import("react").JSX.Element;
declare function CalendarCell({ className, ...props }: CalendarCellProps): import("react").JSX.Element;
declare function CalendarGrid({ className, weekdayStyle, ...props }: Omit<CalendarGridProps, "children">): import("react").JSX.Element;
interface CalendarProps<T extends DateValue$1> extends CalendarProps$1<T> {
  /**
   * `"heading"` shows a static "Month Year" heading with prev/next buttons.
   * `"picker"` replaces it with Select-driven month and year dropdowns that
   * jump straight to a month, always shown once regardless of
   * `visibleDuration`.
   *
   * @default "heading"
   */
  header?: "heading" | "picker";
}
declare function Calendar<T extends DateValue$1>({ header, className, ...props }: CalendarProps<T>): import("react").JSX.Element;
interface RangeCalendarProps<T extends DateValue$1> extends RangeCalendarProps$1<T> {
  /**
   * `"heading"` shows a static "Month Year" heading with prev/next buttons.
   * `"picker"` replaces it with Select-driven month and year dropdowns that
   * jump straight to a month, always shown once regardless of
   * `visibleDuration`.
   *
   * @default "heading"
   */
  header?: "heading" | "picker";
}
declare function RangeCalendar<T extends DateValue$1>({ header, className, ...props }: RangeCalendarProps<T>): import("react").JSX.Element;
//#endregion
//#region src/components/calendar/date-field.d.ts
declare const dateInput: (props?: ({
  size?: "small" | "medium" | "large" | undefined;
} & ({
  class?: import("cva").ClassValue;
  className?: never;
} | {
  class?: never;
  className?: import("cva").ClassValue;
})) | undefined) => string;
declare function DateSegment({ className, ...props }: DateSegmentProps): import("react").JSX.Element;
declare function DateInput({ className, size, children, ...props }: Omit<DateInputProps, "children"> & {
  size?: "small" | "medium" | "large";
  children?: DateInputProps["children"];
}): import("react").JSX.Element;
declare function DateField<T extends DateValue$1>({ inputProps, children, size, ...props }: DateFieldProps<T> & {
  inputProps?: Omit<ComponentProps<typeof DateInput>, "size">;
  size?: "small" | "medium" | "large";
}): import("react").JSX.Element;
//#endregion
//#region src/components/calendar/date-picker.d.ts
/** A small calendar glyph for the trigger button. */
declare function CalendarIcon(): import("react").JSX.Element;
declare const dateGroup: (props?: ({
  size?: "small" | "medium" | "large" | undefined;
} & ({
  class?: import("cva").ClassValue;
  className?: never;
} | {
  class?: never;
  className?: import("cva").ClassValue;
})) | undefined) => string;
/**
 * The borderless `DateInput` used inside a `DatePicker`/`DateRangePicker`'s
 * `Group`, which draws the border itself. `DateField`/`TimeField` use the
 * standalone, self-bordered `DateInput` from "./date-field" instead.
 */
declare function PickerDateInput({ className, children, ...props }: Omit<ComponentProps<typeof DateInput$1>, "children"> & {
  children?: ComponentProps<typeof DateInput$1>["children"];
}): import("react").JSX.Element;
declare function DatePickerButton({ className, children, ...props }: ButtonProps): import("react").JSX.Element;
declare function DatePickerPopover({ className, ...props }: PopoverProps): import("react").JSX.Element;
declare function DatePicker<T extends DateValue$1>({ children, groupProps, inputProps, buttonProps, popoverProps, calendarProps, size, ...props }: DatePickerProps<T> & {
  groupProps?: ComponentProps<typeof Group$1>;
  inputProps?: ComponentProps<typeof PickerDateInput>;
  buttonProps?: ButtonProps;
  popoverProps?: PopoverProps;
  calendarProps?: Omit<CalendarProps<T>, "value" | "defaultValue" | "onChange">;
  size?: "small" | "medium" | "large";
}): import("react").JSX.Element;
//#endregion
//#region src/components/calendar/date-range-picker.d.ts
declare function DateRangePicker<T extends DateValue$1>({ children, groupProps, startInputProps, endInputProps, buttonProps, popoverProps, calendarProps, size, shouldCloseOnSelect, ...props }: DateRangePickerProps<T> & {
  groupProps?: ComponentProps<typeof Group$1>;
  startInputProps?: ComponentProps<typeof PickerDateInput>;
  endInputProps?: ComponentProps<typeof PickerDateInput>;
  buttonProps?: ButtonProps;
  popoverProps?: PopoverProps;
  calendarProps?: Omit<RangeCalendarProps<T>, "value" | "defaultValue" | "onChange">;
  size?: "small" | "medium" | "large";
}): import("react").JSX.Element;
//#endregion
//#region src/components/calendar/time-field.d.ts
declare function TimeField<T extends TimeValue$1>({ inputProps, children, size, ...props }: TimeFieldProps<T> & {
  inputProps?: Omit<ComponentProps<typeof DateInput>, "size">;
  size?: "small" | "medium" | "large";
}): import("react").JSX.Element;
//#endregion
//#region src/components/checkbox/checkbox.d.ts
declare function CheckboxButton({ children, className, ...props }: CheckboxButtonProps): import("react").JSX.Element;
declare function CheckboxField({ className, ...props }: CheckboxFieldProps): import("react").JSX.Element;
declare function Checkbox({ children, className, ...props }: Omit<CheckboxFieldProps, "children" | "className"> & Pick<CheckboxButtonProps, "children" | "className">): import("react").JSX.Element;
//#endregion
//#region src/components/disclosure.d.ts
declare const DisclosureGroup: import("react").ForwardRefExoticComponent<import("react-aria-components").DisclosureGroupProps & import("react").RefAttributes<HTMLDivElement>>;
declare function DisclosureButton({ children, className, ...props }: ButtonProps): import("react").JSX.Element;
declare function Disclosure({ className, ...props }: DisclosureProps): import("react").JSX.Element;
declare function DisclosurePanel({ className, ...props }: DisclosurePanelProps): import("react").JSX.Element;
//#endregion
//#region src/components/divider.d.ts
interface DividerProps extends React.HTMLAttributes<HTMLDivElement> {
  preset?: "left" | "center" | "right";
  hrProps?: React.HTMLAttributes<HTMLHRElement>;
  childrenWrapperProps?: React.HTMLAttributes<HTMLDivElement>;
}
declare function Divider({ preset, hrProps: { className: hrClassName, ...hrProps }, childrenWrapperProps: { className: childrenWrapperClassName, ...childrenWrapperProps }, className, children, ...rest }: DividerProps): import("react").JSX.Element;
//#endregion
//#region src/components/group.d.ts
declare const group: (props?: ({
  size?: "small" | "medium" | "large" | undefined;
} & ({
  class?: import("cva").ClassValue;
  className?: never;
} | {
  class?: never;
  className?: import("cva").ClassValue;
})) | undefined) => string;
interface GroupProps extends GroupProps$1 {
  size?: "small" | "medium" | "large";
}
/**
 * Visually merges several focusable controls (inputs, buttons, static
 * segments) into what reads as a single bordered field, e.g. a summoner name
 * plus its `#`-prefixed tag. `Group` draws the border itself, so children
 * meant to sit inside it should stay borderless — see `GroupInput` and
 * `GroupSeparator`.
 */
declare function Group({ size, className, ...props }: GroupProps): import("react").JSX.Element;
/** A borderless text input for use as a segment inside a `Group`. */
declare function GroupInput({ className, ...props }: ComponentProps<typeof Input>): import("react").JSX.Element;
/** A static, non-interactive segment for use inside a `Group`, e.g. a `#` between a name and its tag. */
declare function GroupSeparator({ className, ...props }: ComponentProps<"span">): import("react").JSX.Element;
//#endregion
//#region src/components/menu/menu.d.ts
declare const MenuTrigger: typeof MenuTrigger$1;
declare const SubmenuTrigger: (props: import("react-aria-components").SubmenuTriggerProps & React.RefAttributes<HTMLDivElement>) => import("react").ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;
declare function Menu<T extends object>({ className, ...props }: MenuProps$1<T>): import("react").JSX.Element;
declare function MenuItem<T extends object>({ className, ...props }: MenuItemProps$1<T>): import("react").JSX.Element;
declare function MenuPopover({ className, ...props }: PopoverProps): import("react").JSX.Element;
declare function MenuSection<T extends object>({ className, ...props }: MenuSectionProps<T>): import("react").JSX.Element;
declare function MenuHeader({ className, ...props }: ComponentProps<typeof Header>): import("react").JSX.Element;
declare function MenuSeparator({ className, ...props }: SeparatorProps): import("react").JSX.Element;
declare function MenuVirtualizer<T>(props: Omit<VirtualizerProps<T>, "layout" | "layoutOptions">): import("react").JSX.Element;
//#endregion
//#region src/components/modal.d.ts
interface ModalProps extends Omit<ModalOverlayProps, "children"> {
  modalOverlayClassName?: ModalOverlayProps["className"];
  dialogProps?: Omit<DialogProps, "children">;
  children?: DialogProps["children"];
}
declare function Modal({ modalOverlayClassName, dialogProps, children, className, ...modalProps }: ModalProps): import("react").JSX.Element;
declare function DialogHeading({ className, ...props }: HeadingProps): import("react").JSX.Element;
declare function DialogButtons({ children }: {
  children: React.ReactNode;
}): import("react").JSX.Element;
//#endregion
//#region src/components/number-field.d.ts
type NumberFieldPreset = "normal" | "dimmed";
declare function NumberField({ inputProps, groupProps, children, preset, size, ...props }: NumberFieldProps & {
  inputProps?: ComponentProps<typeof Input>;
  groupProps?: ComponentProps<typeof Group$1>;
  preset?: NumberFieldPreset;
  size?: "small" | "medium" | "large";
}): import("react").JSX.Element;
//#endregion
//#region src/components/popover.d.ts
declare function Popover({ children, className, ...props }: PopoverProps): import("react").JSX.Element;
declare function PopoverBody({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;
//#endregion
//#region src/components/preview-trigger.d.ts
declare const previewButton: (props?: ({
  class?: import("cva").ClassValue;
  className?: never;
} | {
  class?: never;
  className?: import("cva").ClassValue;
}) | undefined) => string;
type PreviewButtonProps = ButtonProps & {
  ref?: Ref<HTMLButtonElement>;
};
/**
 * A term inside running text that reveals a preview: it inherits the size,
 * weight and leading of the sentence it sits in and marks itself with a dashed
 * gold underline, which goes solid while the preview is open.
 *
 * Use it as the trigger of a `PreviewTrigger` for a term the reader may not
 * know — an item, a rune, a stat — where a `Button` would interrupt the
 * sentence and a plain `<span>` would give a keyboard or screen reader user
 * nothing to act on. It is a real button, so it also works as the trigger of a
 * `DialogTrigger` (a toggle tip). When the term should also navigate
 * somewhere, use a `ButtonLink` or apply the exported `previewButton` styles
 * to a `Link` instead — a preview is never the only way to reach content.
 *
 * ```tsx
 * <PreviewTrigger>
 *   <PreviewButton>Doran's Blade</PreviewButton>
 *   <Popover>
 *     <PopoverBody>…</PopoverBody>
 *   </Popover>
 * </PreviewTrigger>
 * ```
 */
declare function PreviewButton({ children, className, ref, ...props }: PreviewButtonProps): import("react").JSX.Element;
//#endregion
//#region src/components/progress-bar.d.ts
interface ProgressBarProps$1 extends Omit<ProgressBarProps, "children"> {
  label?: string;
}
declare function ProgressBar({ className, label, ...props }: ProgressBarProps$1): JSX.Element;
//#endregion
//#region src/components/radio-group/radio-group.d.ts
declare function RadioGroup({ className, ...props }: RadioGroupProps): import("react").JSX.Element;
declare function RadioButton({ className, ...props }: RadioButtonProps): import("react").JSX.Element;
declare function RadioField({ className, ...props }: RadioFieldProps): import("react").JSX.Element;
declare function Radio({ children, className, ...props }: Omit<RadioFieldProps, "children" | "className"> & Pick<RadioButtonProps, "children" | "className">): import("react").JSX.Element;
//#endregion
//#region src/components/search-field/search-field.d.ts
declare function SearchField({ inputProps, borderProps, children, className, size, ...props }: SearchFieldProps & {
  inputProps?: ComponentProps<typeof Input>;
  borderProps?: ComponentProps<"div">;
  size?: "small" | "medium" | "large";
}): import("react").JSX.Element;
//#endregion
//#region src/components/select/multiple-select.d.ts
interface MultipleSelectProps<T extends object = {}> extends Omit<SelectProps<T, "multiple">, "children" | "className" | "validationBehavior" | "selectionMode"> {
  items: Array<T>;
  className?: string;
  size?: "small" | "medium" | "large";
  emptyTags?: React$1.ReactNode;
  emptyList?: React$1.ReactNode;
  tagGroupLabel?: string;
  selectId: (item: T) => Key$1;
  selectLabel: (item: T) => string;
}
declare function MultipleSelect<T extends object = {}>({ items, className, size, emptyList, emptyTags, tagGroupLabel, selectId, selectLabel, ...selectProps }: MultipleSelectProps<T>): React$1.JSX.Element;
//#endregion
//#region src/components/select/select.d.ts
declare const select: (props?: ({
  size?: "small" | "medium" | "large" | undefined;
  selectionMode?: "single" | "multiple" | undefined;
} & ({
  class?: import("cva").ClassValue;
  className?: never;
} | {
  class?: never;
  className?: import("cva").ClassValue;
})) | undefined) => string;
declare function SelectButton({ className, size, ...props }: ButtonProps & {
  size?: "small" | "medium" | "large";
}): import("react").JSX.Element;
declare function SelectPopover({ className, ...props }: PopoverProps): import("react").JSX.Element;
declare function SelectListBox<T extends object>({ className, emptyList, ...props }: ListBoxProps<T> & {
  emptyList?: React.ReactNode;
}): import("react").JSX.Element;
declare function SelectListBoxItem({ className, ...props }: ListBoxItemProps): import("react").JSX.Element;
declare function SelectVirtualizer<T>(props: Omit<VirtualizerProps<T>, "layout" | "layoutOptions">): import("react").JSX.Element;
//#endregion
//#region src/components/slider/slider.d.ts
declare function Slider<T extends number | number[]>({ children, className, sliderThumbProps, sliderTrackProps, sliderTrackBackgroundClassName, sliderTrackForegroundClassName, ...props }: SliderProps<T> & {
  sliderTrackProps?: SliderTrackProps;
  sliderThumbProps?: SliderThumbProps;
  sliderTrackBackgroundClassName?: string | ((values: SliderTrackRenderProps) => string);
  sliderTrackForegroundClassName?: string | ((values: SliderFillRenderProps) => string);
}): import("react").JSX.Element;
declare function SliderOutput({ children, className, ...props }: SliderOutputProps): import("react").JSX.Element;
//#endregion
//#region src/components/sonner/sonner-types.d.ts
type ToastTypes = "normal" | "action" | "success" | "info" | "warning" | "error" | "loading" | "default";
type PromiseT<Data = unknown> = Promise<Data> | (() => Promise<Data>);
interface PromiseIExtendedResult extends ExternalToast$1 {
  message: React.ReactNode;
}
type PromiseTExtendedResult<Data = unknown> = PromiseIExtendedResult | ((data: Data) => PromiseIExtendedResult | Promise<PromiseIExtendedResult>);
type PromiseTResult<Data = unknown> = string | React.ReactNode | ((data: Data) => React.ReactNode | string | Promise<React.ReactNode | string>);
type PromiseExternalToast = Omit<ExternalToast$1, "description">;
type PromiseData<ToastData = unknown> = PromiseExternalToast & {
  loading?: string | React.ReactNode;
  success?: PromiseTResult<ToastData> | PromiseTExtendedResult<ToastData>;
  error?: PromiseTResult | PromiseTExtendedResult;
  description?: PromiseTResult;
  finally?: () => void | Promise<void>;
};
interface ToastClassnames {
  toast?: string;
  title?: string;
  description?: string;
  loader?: string;
  closeButton?: string;
  cancelButton?: string;
  actionButton?: string;
  success?: string;
  error?: string;
  info?: string;
  warning?: string;
  loading?: string;
  default?: string;
  content?: string;
  icon?: string;
}
interface Action {
  label: React.ReactNode;
  onClick: (event: React.MouseEvent<HTMLButtonElement, MouseEvent>) => void;
  actionButtonStyle?: React.CSSProperties;
}
interface ToastT {
  id: number | string;
  title?: (() => React.ReactNode) | React.ReactNode;
  type?: ToastTypes;
  icon?: React.ReactNode;
  jsx?: React.ReactNode;
  richColors?: boolean;
  invert?: boolean;
  closeButton?: boolean;
  dismissible?: boolean;
  description?: (() => React.ReactNode) | React.ReactNode;
  duration?: number;
  delete?: boolean;
  action?: Action | React.ReactNode;
  cancel?: Action | React.ReactNode;
  onDismiss?: (toast: ToastT) => void;
  onAutoClose?: (toast: ToastT) => void;
  promise?: PromiseT;
  cancelButtonStyle?: React.CSSProperties;
  actionButtonStyle?: React.CSSProperties;
  style?: React.CSSProperties;
  unstyled?: boolean;
  className?: string;
  classNames?: ToastClassnames;
  descriptionClassName?: string;
  position?: Position;
}
type Position = "top-left" | "top-right" | "bottom-left" | "bottom-right" | "top-center" | "bottom-center";
interface ToastToDismiss {
  id: number | string;
  dismiss: boolean;
}
type ExternalToast$1 = Omit<ToastT, "id" | "type" | "title" | "jsx" | "delete" | "promise"> & {
  id?: number | string;
};
type titleT = (() => React.ReactNode) | React.ReactNode;
type Toast = ((message: titleT, data?: ExternalToast$1) => string | number) & {
  success: (message: titleT | React.ReactNode, data?: ExternalToast$1) => string | number;
  info: (message: titleT | React.ReactNode, data?: ExternalToast$1) => string | number;
  warning: (message: titleT | React.ReactNode, data?: ExternalToast$1) => string | number;
  error: (message: titleT | React.ReactNode, data?: ExternalToast$1) => string | number;
  custom: (jsx: (id: number | string) => React.ReactElement, data?: ExternalToast$1) => string | number;
  message: (message: titleT | React.ReactNode, data?: ExternalToast$1) => string | number;
  promise: <ToastData>(promise: PromiseT<ToastData>, data?: PromiseData<ToastData>) => (string & {
    unwrap: () => Promise<ToastData>;
  }) | (number & {
    unwrap: () => Promise<ToastData>;
  }) | {
    unwrap: () => Promise<ToastData>;
  };
  dismiss: (id?: number | string) => string | number;
  loading: (message: titleT | React.ReactNode, data?: ExternalToast$1) => string | number;
} & {
  getHistory: () => (ToastT | ToastToDismiss)[];
  getToasts: () => (ToastT | ToastToDismiss)[];
};
//#endregion
//#region src/components/sonner/sonner.d.ts
type ToastVariant = "default" | "hextech";
declare const sonner: Toast;
type SonnerProps = ExternalToast;
declare function Sonner(props: ToasterProps): import("react").JSX.Element;
//#endregion
//#region src/components/spinner/spinner.d.ts
interface SpinnerProps {
  className?: string;
}
declare function Spinner({ className }: SpinnerProps): import("react").JSX.Element;
//#endregion
//#region src/components/switch.d.ts
declare function SwitchButton({ className, children, ...props }: SwitchButtonProps): import("react").JSX.Element;
declare function SwitchField({ className, ...props }: SwitchFieldProps): import("react").JSX.Element;
declare function Switch({ children, className, ...props }: Omit<SwitchFieldProps, "children" | "className"> & Pick<SwitchButtonProps, "children" | "className">): import("react").JSX.Element;
//#endregion
//#region src/components/table/table.d.ts
/** Horizontal alignment shared by `TableColumn` and `TableCell`. */
type TableAlign = "start" | "center" | "end";
declare const table: (props?: ({
  class?: import("cva").ClassValue;
  className?: never;
} | {
  class?: never;
  className?: import("cva").ClassValue;
}) | undefined) => string;
interface TableProps extends TableProps$1 {}
declare function Table({ className, ...props }: TableProps): import("react").JSX.Element;
interface ResizableTableContainerProps extends ResizableTableContainerProps$1 {}
/**
 * The scroll container a `Table` needs for `allowsResizing` columns: it is the
 * element the column widths are measured against.
 */
declare function ResizableTableContainer({ className, ...props }: ResizableTableContainerProps): import("react").JSX.Element;
interface TableHeaderProps<T extends object> extends TableHeaderProps$1<T> {}
/**
 * The header row of a `Table`.
 *
 * The select-all checkbox is added for tables with `selectionMode="multiple"`,
 * and a blank column ahead of it for tables that allow dragging, so that the
 * header keeps a column for every cell `TableRow` adds.
 */
declare function TableHeader<T extends object>({ children, className, columns, dependencies, ...props }: TableHeaderProps<T>): import("react").JSX.Element;
declare const tableColumn: (props?: ({
  align?: "start" | "center" | "end" | undefined;
} & ({
  class?: import("cva").ClassValue;
  className?: never;
} | {
  class?: never;
  className?: import("cva").ClassValue;
})) | undefined) => string;
interface TableColumnProps extends ColumnProps {
  align?: TableAlign;
}
declare function TableColumn({ align, children, className, ...props }: TableColumnProps): import("react").JSX.Element;
interface TableColumnResizerProps extends ColumnResizerProps {}
declare function TableColumnResizer({ className, ...props }: TableColumnResizerProps): import("react").JSX.Element;
interface TableBodyProps<T extends object> extends TableBodyProps$1<T> {
  /** Rendered when the table has no rows. */
  emptyState?: React.ReactNode;
}
declare function TableBody<T extends object>({ emptyState, renderEmptyState, ...props }: TableBodyProps<T>): import("react").JSX.Element;
declare const tableRow: (props?: ({
  class?: import("cva").ClassValue;
  className?: never;
} | {
  class?: never;
  className?: import("cva").ClassValue;
}) | undefined) => string;
interface TableRowProps<T extends object> extends RowProps<T> {}
/**
 * A row of a `Table`.
 *
 * A selection checkbox is added for tables with a `selectionMode`, and a drag
 * handle for tables that allow dragging — both ahead of the row's own cells,
 * matching the columns `TableHeader` adds. `selectionBehavior="replace"` drops
 * the checkbox in favour of highlighting the row, like the ladder in the
 * League client.
 */
declare function TableRow<T extends object>({ children, className, columns, dependencies, ...props }: TableRowProps<T>): import("react").JSX.Element;
declare const tableCell: (props?: ({
  align?: "start" | "center" | "end" | undefined;
} & ({
  class?: import("cva").ClassValue;
  className?: never;
} | {
  class?: never;
  className?: import("cva").ClassValue;
})) | undefined) => string;
interface TableCellProps extends CellProps {
  align?: TableAlign;
}
/**
 * A cell of a `TableRow`.
 *
 * The cell in the table's `treeColumn` grows an expand chevron for rows that
 * have child rows, and is indented by the row's depth; the indent is read from
 * the `--table-row-level` react aria sets on every row.
 */
declare function TableCell({ align, children, className, ...props }: TableCellProps): import("react").JSX.Element;
interface TableFooterProps<T extends object> extends TableFooterProps$1<T> {}
declare function TableFooter<T extends object>({ className, ...props }: TableFooterProps<T>): import("react").JSX.Element;
interface TableLoadMoreItemProps extends TableLoadMoreItemProps$1 {}
/**
 * A sentinel row at the end of a `TableBody`. It calls `onLoadMore` once it
 * scrolls into view, and shows the spinner while `isLoading` is set.
 */
declare function TableLoadMoreItem({ children, className, ...props }: TableLoadMoreItemProps): import("react").JSX.Element;
interface TableDropIndicatorProps extends DropIndicatorProps {}
/**
 * The line drawn between two rows while a drop is hovered over the gap. It is
 * rendered by `useTableDragAndDrop` — pass it to `useDragAndDrop`'s
 * `renderDropIndicator` when using that hook directly.
 */
declare function TableDropIndicator({ className, ...props }: TableDropIndicatorProps): import("react").JSX.Element;
/**
 * `useDragAndDrop` with the table's own drop indicator, for the
 * `dragAndDropHooks` prop of a `Table`.
 */
declare function useTableDragAndDrop<T = object>(options: DragAndDropOptions$1<T>): {
  dragAndDropHooks: DragAndDropHooks$1<T>;
};
//#endregion
//#region src/components/tabs.d.ts
declare const Tabs: (props: import("react-aria-components").TabsProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;
declare function TabList<T extends object>({ className, ...rest }: TabListProps<T>): import("react").JSX.Element;
declare function Tab({ children, className, ...rest }: TabProps): import("react").JSX.Element;
declare function TabPanel({ ...rest }: TabPanelProps): import("react").JSX.Element;
//#endregion
//#region src/components/tag-group/tag-group.d.ts
interface TagProps extends TagProps$1 {
  variant?: "gold" | "hextech" | "grey";
}
declare function Tag({ children, className, variant, ...props }: TagProps): import("react").JSX.Element;
declare const tagGroup: (props?: ({
  class?: import("cva").ClassValue;
  className?: never;
} | {
  class?: never;
  className?: import("cva").ClassValue;
}) | undefined) => string;
interface TagGroupProps extends TagGroupProps$1 {}
declare function TagGroup({ children, className, ...props }: TagGroupProps): import("react").JSX.Element;
declare const tagList: (props?: ({
  class?: import("cva").ClassValue;
  className?: never;
} | {
  class?: never;
  className?: import("cva").ClassValue;
}) | undefined) => string;
interface TagListProps<T extends object = {}> extends TagListProps$1<T> {
  children?: React.ReactNode;
  className?: string;
  selectLabel: (item: T) => string;
  variant?: TagProps["variant"];
}
declare function TagList<T extends object>({ children, className, selectLabel, variant, ...props }: TagListProps<T> & {
  selectLabel: (item: T) => string;
  variant?: TagProps["variant"];
}): import("react").JSX.Element;
//#endregion
//#region src/components/text-area.d.ts
declare function TextArea({ textAreaProps, children, ...props }: TextFieldProps & {
  textAreaProps?: TextAreaProps;
}): import("react").JSX.Element;
//#endregion
//#region src/components/text-field.d.ts
declare const textField: (props?: ({
  size?: "small" | "medium" | "large" | undefined;
  isTextArea?: boolean | undefined;
} & ({
  class?: import("cva").ClassValue;
  className?: never;
} | {
  class?: never;
  className?: import("cva").ClassValue;
})) | undefined) => string;
declare function TextField({ inputProps, borderProps, children, size, ...props }: TextFieldProps & {
  inputProps?: InputProps;
  borderProps?: ComponentProps<"div">;
  size?: "small" | "medium" | "large";
}): import("react").JSX.Element;
//#endregion
//#region src/components/toggle-button.d.ts
type ToggleButtonPreset = "secondary" | "hextech" | "dimmed";
interface ToggleButtonProps$1 extends ToggleButtonProps {
  preset?: ToggleButtonPreset;
  thin?: boolean;
  shape?: ButtonShape;
  size?: ButtonSize;
}
declare function ToggleButton({ children, className, preset, shape, size, thin, ...props }: ToggleButtonProps$1): import("react").JSX.Element;
//#endregion
//#region src/components/toggle-button-group.d.ts
interface ToggleButtonGroupProps extends ToggleButtonGroupProps$1 {}
declare function ToggleButtonGroup({ className, ...props }: ToggleButtonGroupProps): import("react").JSX.Element;
//#endregion
//#region src/components/token-field/token-field.d.ts
/**
 * A text field with inline, non-editable tokens: an `@summoner` mention, a
 * `#tag`, a champion picked from a menu. Text and tokens share one caret, so it
 * reads and edits as a single field rather than as an input with chips beside
 * it.
 *
 * ```tsx
 * <TokenField value={value} onChange={setValue}>
 *   <Label>Prompt</Label>
 *   <TokenInput placeholder="Mention a @summoner">
 *     {(segment) => <Token>{segment.text}</Token>}
 *   </TokenInput>
 * </TokenField>
 * ```
 *
 * This is React Aria's own note, and it holds here too: `TokenField` is alpha
 * upstream, so its API may still move under us.
 */
declare function TokenField<T extends TokenFieldValue$1 = TokenFieldValue$1>({ className, ...props }: TokenFieldProps<T>): import("react").JSX.Element;
declare const tokenInput: (props?: ({
  size?: "small" | "medium" | "large" | undefined;
} & ({
  class?: import("cva").ClassValue;
  className?: never;
} | {
  class?: never;
  className?: import("cva").ClassValue;
})) | undefined) => string;
interface TokenInputProps<T extends TokenFieldValue$1 = TokenFieldValue$1> extends TokenInputProps$1<T> {
  size?: "small" | "medium" | "large";
  /** Shown while the field is empty; painted by the field, not by the UA. */
  placeholder?: string;
}
/** The editable area of a `TokenField`, rendering a `Token` per token segment. */
declare function TokenInput<T extends TokenFieldValue$1 = TokenFieldValue$1>({ className, placeholder, size, ...props }: TokenInputProps<T>): import("react").JSX.Element;
declare const token: (props?: ({
  variant?: "hextech" | "gold" | "grey" | undefined;
} & ({
  class?: import("cva").ClassValue;
  className?: never;
} | {
  class?: never;
  className?: import("cva").ClassValue;
})) | undefined) => string;
interface TokenProps extends TokenProps$1 {
  variant?: "gold" | "hextech" | "grey";
}
/** One non-editable segment inside a `TokenInput`. */
declare function Token({ className, variant, ...props }: TokenProps): import("react").JSX.Element;
//#endregion
//#region src/components/toolbar.d.ts
interface ToolbarProps extends ToolbarProps$1 {}
declare function Toolbar({ className, ...props }: ToolbarProps): import("react").JSX.Element;
interface ToolbarSeparatorProps extends SeparatorProps {}
/**
 * Separates groups of controls inside a `Toolbar`. Defaults to the orientation
 * that crosses a horizontal toolbar; pass `orientation="horizontal"` when the
 * toolbar itself is vertical.
 */
declare function ToolbarSeparator({ className, orientation, ...props }: ToolbarSeparatorProps): import("react").JSX.Element;
//#endregion
//#region src/components/tree/tree.d.ts
declare const tree: (props?: ({
  class?: import("cva").ClassValue;
  className?: never;
} | {
  class?: never;
  className?: import("cva").ClassValue;
}) | undefined) => string;
interface TreeProps<T> extends TreeProps$1<T> {
  /** Rendered when the tree has no items. */
  emptyState?: React.ReactNode;
}
declare function Tree<T extends object>({ className, emptyState, renderEmptyState, ...props }: TreeProps<T>): import("react").JSX.Element;
declare const treeItem: (props?: ({
  class?: import("cva").ClassValue;
  className?: never;
} | {
  class?: never;
  className?: import("cva").ClassValue;
}) | undefined) => string;
interface TreeItemProps<T = object> extends TreeItemProps$1<T> {}
declare function TreeItem<T = object>({ className, ...props }: TreeItemProps<T>): import("react").JSX.Element;
interface TreeItemContentProps extends TreeItemContentProps$1 {}
/**
 * The row of a `TreeItem`, holding everything but its nested items.
 *
 * The expand chevron is added for items that have children, and a selection
 * checkbox for trees with `selectionMode="multiple"`. Setting
 * `selectionBehavior="replace"` drops the checkbox in favour of highlighting
 * the row, like the ladder in the League client.
 */
declare function TreeItemContent({ children }: TreeItemContentProps): import("react").JSX.Element;
interface TreeLoadMoreItemProps extends TreeLoadMoreItemProps$1 {}
declare function TreeLoadMoreItem({ children, className, ...props }: TreeLoadMoreItemProps): import("react").JSX.Element;
//#endregion
//#region src/components/typography/heading.d.ts
type HeadingColor = "gold100" | "gold200" | "gold400" | "grey100";
type HeadingElement = "h1" | "h2" | "h3" | "h4" | "h5";
interface HeadingProps$1 extends React.DetailedHTMLProps<React.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement> {
  preset?: HeadingElement;
  color?: HeadingColor;
  as?: HeadingElement | "span";
}
declare const heading: (props?: ({
  color?: "gold100" | "gold200" | "gold400" | "grey100" | undefined;
  preset?: "h1" | "h2" | "h3" | "h4" | "h5" | undefined;
} & ({
  class?: import("cva").ClassValue;
  className?: never;
} | {
  class?: never;
  className?: import("cva").ClassValue;
})) | undefined) => string;
declare function Heading({ as, preset, color, className, ...rest }: HeadingProps$1): JSX.Element;
//#endregion
//#region src/components/typography/text.d.ts
type TextColor = "grey100" | "grey150" | "gold100";
type TextElement = "p" | "span" | "div";
type TextPreset = "sm" | "base" | "md" | "lg" | "largeNumber" | "stat";
declare const text: (props?: ({
  color?: "gold100" | "grey100" | "grey150" | undefined;
  preset?: "sm" | "base" | "md" | "lg" | "label" | "largeNumber" | "stat" | undefined;
} & ({
  class?: import("cva").ClassValue;
  className?: never;
} | {
  class?: never;
  className?: import("cva").ClassValue;
})) | undefined) => string;
interface TextProps$1 extends TextProps {
  preset?: TextPreset;
  color?: TextColor;
}
declare function Text({ preset, color, className, ...rest }: TextProps$1): JSX.Element;
interface LabelProps$1 extends LabelProps {
  preset?: TextPreset | "label";
  color?: TextColor;
}
declare function Label({ preset, color, className, ...rest }: LabelProps$1): JSX.Element;
//#endregion
//#region src/components/vertical-table/vertical-table.d.ts
/** Horizontal alignment of a `VerticalTable`'s value cells. */
type VerticalTableAlign = "start" | "center" | "end";
/** One field of a `VerticalTable`: a row, read across every record. */
interface VerticalTableField<T> {
  /** The name of the field, which heads its row. */
  name: ReactNode;
  /** What this field is for one record, for every column of the row. */
  value: (record: T, index: number) => ReactNode;
  /** Overrides the table's `align` for this row. */
  align?: VerticalTableAlign;
  /** Distinguishes the row between renders. Defaults to the field's index. */
  id?: Key$2;
}
declare const verticalTable: (props?: ({
  class?: import("cva").ClassValue;
  className?: never;
} | {
  class?: never;
  className?: import("cva").ClassValue;
}) | undefined) => string;
declare const verticalTableCell: (props?: ({
  align?: "start" | "center" | "end" | undefined;
} & ({
  class?: import("cva").ClassValue;
  className?: never;
} | {
  class?: never;
  className?: import("cva").ClassValue;
})) | undefined) => string;
declare const verticalTableRecordHeader: (props?: ({
  align?: "start" | "center" | "end" | undefined;
} & ({
  class?: import("cva").ClassValue;
  className?: never;
} | {
  class?: never;
  className?: import("cva").ClassValue;
})) | undefined) => string;
interface VerticalTableProps<T> extends Omit<TableHTMLAttributes<HTMLTableElement>, "align" | "children"> {
  /** The records, one per column. */
  records: readonly T[];
  /** The fields, one per row. */
  fields: readonly VerticalTableField<T>[];
  /**
   * The heading over a record's column. Leave it out and the table has no
   * header row at all, which is the stat card of a single record: the field
   * names head their own rows, so nothing is left unnamed by dropping it.
   */
  recordHeader?: (record: T, index: number) => ReactNode;
  /** Distinguishes a column between renders. Defaults to the record's index. */
  recordKey?: (record: T, index: number) => Key$2;
  /** Where the values sit in their cells. Defaults to `"start"`. */
  align?: VerticalTableAlign;
}
/**
 * A table read down rather than across: a row per field, a column per record,
 * and the field names heading the rows from the leading column.
 *
 * It is the table for comparing a handful of records field by field — two
 * builds, the champions of a lane — and, with a single record and no
 * `recordHeader`, for the stat card that is a table underneath.
 *
 * Where `Table` is React Aria's grid, with everything that comes with it, this
 * is markup and no more: a `<table>` whose field names are real
 * `<th scope="row">`s and whose record headings are real `<th scope="col">`s.
 * Nothing here is selectable, sortable, resizable or focusable. React Aria's
 * table cannot be transposed — its collection is row major, and the flip is in
 * the data rather than in the structure — so rather than dress one up as the
 * other, a table that only has to be read is only what a table needs to be
 * read. Reach for `Table` the moment the rows have to be interacted with.
 */
declare function VerticalTable<T>({ align, className, fields, recordHeader, recordKey, records, ...props }: VerticalTableProps<T>): import("react").JSX.Element;
//#endregion
export { type AsyncListData, type AsyncListOptions, Autocomplete, AutocompleteContext, AutocompleteStateContext, Breadcrumb, Breadcrumbs, Button, ButtonLink, ButtonPreset, ButtonShape, ButtonSize, Calendar, CalendarCell, CalendarGrid, CalendarGridHeader, CalendarHeaderCell, CalendarIcon, CalendarProps, Checkbox, CheckboxButton, CheckboxField, Collection, DateField, DateInput, DatePicker, DatePickerButton, DatePickerPopover, DateRangePicker, DateSegment, type DateValue, Dialog, DialogButtons, DialogHeading, DialogTrigger, Disclosure, DisclosureButton, DisclosureGroup, DisclosurePanel, Divider, type DragAndDropHooks, type DragAndDropOptions, type DropItem, type DropTarget, FieldError, Focusable, GridLayout, Group, GroupInput, GroupProps, GroupSeparator, Heading, HeadingColor, HeadingElement, type Key, Label, ListBoxItem, type ListData, ListLayout, Menu, MenuHeader, MenuItem, type MenuItemProps, MenuPopover, type MenuProps, MenuSection, MenuSeparator, MenuTrigger, MenuVirtualizer, Modal, MultipleSelect, MultipleSelectProps, NumberField, PickerDateInput, Popover, PopoverBody, Pressable, PreviewButton, PreviewButtonProps, PreviewTrigger, type PreviewTriggerProps, ProgressBar, Radio, RadioButton, RadioField, RadioGroup, RangeCalendar, RangeCalendarProps, ResizableTableContainer, ResizableTableContainerProps, RouterProvider, SearchField, Select, SelectButton, SelectListBox, SelectListBoxItem, SelectPopover, SelectValue, SelectVirtualizer, type Selection, Size, Slider, SliderOutput, Sonner, SonnerProps, type SortDescriptor, type SortDirection, Spinner, SubmenuTrigger, Switch, SwitchButton, SwitchField, Tab, TabList, TabPanel, Table, TableAlign, TableBody, TableBodyProps, TableCell, TableCellProps, TableColumn, TableColumnProps, TableColumnResizer, TableColumnResizerProps, TableDropIndicator, TableDropIndicatorProps, TableFooter, TableFooterProps, TableHeader, TableHeaderProps, TableLayout, TableLoadMoreItem, TableLoadMoreItemProps, TableProps, TableRow, TableRowProps, Tabs, Tag, TagGroup, TagGroupProps, TagList, TagListProps, TagProps, Text, TextArea, TextColor, type TextDropItem, TextElement, TextField, TextPreset, TimeField, type TimeValue, ToastVariant, ToggleButton, ToggleButtonGroup, ToggleButtonGroupProps, ToggleButtonPreset, Token, TokenField, type TokenFieldValue, TokenInput, TokenInputProps, TokenProps, Toolbar, ToolbarProps, ToolbarSeparator, ToolbarSeparatorProps, Tree, TreeItem, TreeItemContent, TreeItemContentProps, TreeItemProps, TreeLoadMoreItem, TreeLoadMoreItemProps, TreeProps, UnstyledPopover, VerticalTable, VerticalTableAlign, VerticalTableField, VerticalTableProps, Virtualizer, WaterfallLayout, button, dateGroup, dateInput, group, heading, isTextDropItem, previewButton, select, sonner, table, tableCell, tableColumn, tableRow, tagGroup, tagList, text, textField, token, tokenInput, tree, treeItem, useAsyncList, useDragAndDrop, useFilter, useListData, useTableDragAndDrop, verticalTable, verticalTableCell, verticalTableRecordHeader };
//# sourceMappingURL=index.d.mts.map