@parrot-co/parrot-ui 0.1.31 → 1.0.0-beta.0

package/dist/index.d.ts

@@ -0,0 +1,773 @@
+import * as React$1 from 'react';
+import React__default from 'react';
+import * as react_aria_components from 'react-aria-components';
+import { TextFieldProps, NumberFieldProps, ButtonProps as ButtonProps$1, ToggleButtonProps as ToggleButtonProps$1, CheckboxFieldProps, CheckboxGroupProps as CheckboxGroupProps$1, MenuTriggerProps as MenuTriggerProps$1, MenuProps as MenuProps$1, Placement, MenuItemProps as MenuItemProps$1, MenuSectionProps as MenuSectionProps$1, ListBoxProps as ListBoxProps$1, ListBoxItemProps as ListBoxItemProps$1, ListBoxSectionProps as ListBoxSectionProps$1, RadioFieldProps, RadioGroupProps as RadioGroupProps$1, CalendarProps as CalendarProps$1, DateValue, RangeCalendarProps as RangeCalendarProps$1, DateFieldProps as DateFieldProps$1, TimeFieldProps as TimeFieldProps$1, TimeValue, DatePickerProps as DatePickerProps$1, DateRangePickerProps as DateRangePickerProps$1, ProgressBarProps, SwitchFieldProps, SliderProps as SliderProps$1, Key, TabsProps as TabsProps$1, Selection, SortDescriptor, ModalOverlayProps, PopoverProps as PopoverProps$1, TagGroupProps as TagGroupProps$1, TagListProps, TagProps as TagProps$1, Color as Color$1, ColorAreaProps as ColorAreaProps$1, ColorFieldProps as ColorFieldProps$1, ColorSwatchPickerProps as ColorSwatchPickerProps$1, ColorSliderProps as ColorSliderProps$1 } from 'react-aria-components';
+import { OverlayTriggerProps } from 'react-stately';
+
+/**
+ * Open registry of valid `color` values. Consumers extend it via module
+ * augmentation to get intellisense for custom colors:
+ *   declare module "@parrot-co/parrot-ui" { interface ParrotColorRegistry { fire: true } }
+ */
+interface ParrotColorRegistry {
+    red: true;
+    orange: true;
+    amber: true;
+    yellow: true;
+    lime: true;
+    green: true;
+    emerald: true;
+    teal: true;
+    cyan: true;
+    sky: true;
+    blue: true;
+    indigo: true;
+    violet: true;
+    purple: true;
+    fuchsia: true;
+    pink: true;
+    rose: true;
+    slate: true;
+    gray: true;
+    zinc: true;
+    neutral: true;
+    stone: true;
+    primary: true;
+    accent: true;
+    success: true;
+    warning: true;
+    critical: true;
+    info: true;
+    /** @deprecated Radix-era names — migrate to the Tailwind equivalents. */
+    tomato: true;
+    crimson: true;
+    plum: true;
+    grass: true;
+    brown: true;
+    mint: true;
+    gold: true;
+    bronze: true;
+    mauve: true;
+    sage: true;
+    olive: true;
+    sand: true;
+}
+type Color = keyof ParrotColorRegistry;
+/**
+ * Open registry of valid `variant` values. Extend via module augmentation.
+ */
+interface ParrotVariantRegistry {
+    solid: true;
+    light: true;
+    outline: true;
+    lightOutline: true;
+    ghost: true;
+    pastel: true;
+    solidMono: true;
+}
+type Variant = keyof ParrotVariantRegistry;
+type ColorVariant = Variant;
+type InputAppearance = "outline" | "filled" | "filled-outline";
+/** The shared control-size scale (`.prt-size` recipe). */
+type Size = "2xs" | "xs" | "sm" | "md" | "lg" | "xl";
+/** The radius scale (`data-radius` recipe). */
+type Radius = "none" | "sm" | "md" | "lg" | "xl" | "2xl" | "full";
+/** @deprecated use `Radius` */
+type BorderRadius = "none" | "sm" | "md" | "lg" | "full";
+type Appearance = "light" | "dark";
+/** @deprecated use `Size` */
+type ButtonSize = "xs" | "sm" | "md" | "lg" | "xl";
+type ButtonAppearance = "primary" | "secondary" | "minimal";
+type ButtonAppearanceSchemaType = Partial<Record<ButtonAppearance, {
+    variant: Variant;
+    color: Color;
+}>>;
+type SizeOption = "none" | "4xs" | "3xs" | "2xs" | "xs" | "sm" | "md" | "lg" | "xl" | "2xl" | "3xl" | "4xl";
+
+type ActionStatus = "idle" | "loading" | "success" | "error";
+type Dict<T = unknown> = Record<string, T>;
+type ID = string | number;
+type Breakpoints = "base" | "sm" | "md" | "lg" | "xl" | "2xl";
+interface StyleProps<S extends string = string> {
+    /** Use this to add classes to the component. you can also use the `className` prop. But i won't recommend to use both at the same time. */
+    classNames?: Partial<Record<S, string>>;
+    /** Use this to add styles to the component. you can also use the `style` prop. But i won't recommend to use both at the same time. */
+    styles?: Partial<Record<S, React.CSSProperties>>;
+    className?: string;
+    style?: React.CSSProperties;
+}
+type ResponsiveProp<T> = T | {
+    [K in Breakpoints]?: T;
+};
+
+type FieldProps<S extends string> = InputProps & StyleProps<S | "wrapper" | "label" | "input" | "description"> & {
+    children?: React__default.ReactNode;
+    replaceDefaultControlWrapper?: boolean;
+};
+type FieldComponentProps<S extends string> = FieldProps<S>;
+type InputProps = {
+    description?: React__default.ReactNode;
+    label?: React__default.ReactNode;
+    error?: React__default.ReactNode;
+    append?: React__default.ReactNode;
+    prepend?: React__default.ReactNode;
+    validationStatus?: "error" | "success" | "warning";
+    shape?: "rounded" | "sharp";
+    inputRef?: React__default.RefObject<HTMLInputElement>;
+    wrapperRef?: React__default.RefObject<HTMLDivElement>;
+    appearance?: InputAppearance;
+    size?: "xs" | "sm" | "md" | "lg" | "xl";
+    color?: Color;
+    radius?: Radius;
+    isDisabled?: boolean;
+};
+
+type TextInputProps = Omit<TextFieldProps, "className" | "style" | "children"> & FieldComponentProps<"input"> & {
+    placeholder?: string;
+};
+declare function Input({ className, classNames, style, styles, onChange, inputRef, wrapperRef, prepend, append, label, description, error, color, size, radius, appearance, validationStatus, shape, placeholder, ...textFieldProps }: TextInputProps): React$1.JSX.Element;
+
+type NumberInputProps = Omit<NumberFieldProps, "className" | "style" | "children"> & FieldComponentProps<"input" | "decrement" | "increment"> & {
+    showSteppers?: boolean;
+    decrementIcon?: React$1.ReactNode;
+    incrementIcon?: React$1.ReactNode;
+    placeholder?: string;
+};
+declare function NumberInput({ appearance, size, color, classNames, styles, append, prepend, placeholder, showSteppers, error, label, description, incrementIcon, decrementIcon, inputRef, wrapperRef, validationStatus, shape, radius, ...props }: NumberInputProps): React$1.JSX.Element;
+
+type TextWeight = "light" | "regular" | "medium" | "semi-bold" | "bold" | "heavy" | "inherit";
+type TextColorVariant = "light" | "lighter" | "dark" | "default";
+interface TextProps extends Omit<React$1.ComponentPropsWithRef<"span">, "color"> {
+    size?: ResponsiveProp<SizeOption>;
+    weight?: TextWeight;
+    highlight?: boolean;
+    color?: Color | "inherit" | "white" | "black";
+    variant?: TextColorVariant;
+    align?: "left" | "center" | "right";
+    numeric?: boolean;
+    underline?: boolean;
+    italic?: boolean;
+    lineHeight?: "normal" | "shorter" | "short" | "base" | "tall";
+    textCase?: "uppercase" | "lowercase" | "capitalize";
+    as?: React$1.ElementType;
+}
+/**
+ * @deprecated Use plain HTML elements (`<span>`, `<p>`, `<div>`) with Tailwind
+ * text utilities (`text-sm`, `font-medium`, `text-gray-500`, …) instead.
+ */
+declare function Text({ textCase, size, weight, color, variant, highlight, align, lineHeight, underline, italic, as: Comp, className, ...rest }: TextProps): React$1.JSX.Element;
+
+interface TextareaProps extends Omit<TextFieldProps, "className" | "style" | "children">, FieldComponentProps<"input"> {
+    resize?: "none" | "both" | "horizontal" | "vertical";
+    placeholder?: string;
+    rows?: number;
+}
+declare function Textarea({ appearance, resize, label, description, error, color, radius, size, className, classNames, styles, style, prepend, append, validationStatus, shape, inputRef, wrapperRef, placeholder, rows, isDisabled, ...textFieldProps }: TextareaProps): React$1.JSX.Element;
+
+interface ButtonProps extends Omit<ButtonProps$1, "className" | "style" | "children">, StyleProps<"wrapper" | "loader"> {
+    append?: React$1.ReactNode;
+    color?: Color;
+    isIconButton?: boolean;
+    isLoading?: boolean;
+    prepend?: React$1.ReactNode;
+    radius?: Radius;
+    size?: Size;
+    variant?: Variant;
+    children?: React$1.ReactNode;
+    ref?: React$1.Ref<HTMLButtonElement>;
+}
+declare function Button(props: ButtonProps): React$1.JSX.Element;
+
+interface SpaceProps extends StyleProps<"wrapper"> {
+    compact?: boolean;
+    gap?: SizeOption;
+    stack?: boolean;
+    children?: React$1.ReactNode;
+}
+declare function Space({ children, compact, gap, stack, className, classNames, style, styles, }: SpaceProps): React$1.JSX.Element;
+
+type ButtonGroupProps = Pick<ButtonProps, "color" | "variant" | "size" | "radius"> & StyleProps<"wrapper"> & {
+    label?: string;
+};
+declare function ButtonGroup({ color, variant, size, compact, radius, gap, children, className, classNames, style, styles, }: ButtonGroupProps & React$1.ComponentProps<typeof Space>): React$1.JSX.Element;
+
+declare function IconButton({ children, ...props }: ButtonProps): React__default.JSX.Element;
+
+interface ButtonToggleProps {
+    idleColor?: Color;
+    idleVariant?: Variant;
+    activeColor?: Color;
+    activeVariant?: Variant;
+}
+interface ToggleButtonProps extends Omit<ToggleButtonProps$1, "className" | "style" | "children">, ButtonToggleProps, StyleProps<"wrapper"> {
+    append?: React$1.ReactNode;
+    prepend?: React$1.ReactNode;
+    radius?: Radius;
+    size?: Size;
+    isIconButton?: boolean;
+    children?: React$1.ReactNode;
+    ref?: React$1.Ref<HTMLButtonElement>;
+}
+declare function ToggleButton({ idleColor, idleVariant, activeColor, activeVariant, append, prepend, size, radius, isIconButton, className, classNames, style, styles, children, ...props }: ToggleButtonProps): React$1.JSX.Element;
+
+interface CheckboxVariantProps extends StyleProps<"wrapper" | "icon" | "checkbox"> {
+    appearance?: "outline" | "filled";
+    size?: "xs" | "sm" | "md" | "lg" | "xl";
+    radius?: Radius;
+    /** @deprecated use `radius` instead */
+    shape?: "sharp" | "round";
+    color?: Color;
+}
+interface CheckboxProps extends Omit<CheckboxFieldProps, "className" | "children" | "style">, CheckboxVariantProps {
+    className?: string;
+    children?: React$1.ReactNode;
+}
+declare function Checkbox({ appearance, size, shape, radius, color, className, classNames, styles, style, children, ...props }: CheckboxProps): React$1.JSX.Element;
+
+interface CheckboxGroupProps extends Omit<CheckboxGroupProps$1, "className" | "style" | "children">, CheckboxVariantProps {
+    children?: React$1.ReactNode;
+    label?: React$1.ReactNode;
+    description?: React$1.ReactNode;
+    errorMessage?: React$1.ReactNode;
+    ref?: React$1.Ref<HTMLDivElement>;
+}
+declare function CheckboxGroup({ children, label, description, errorMessage, size, appearance, color, radius, shape, ...props }: CheckboxGroupProps): React$1.JSX.Element;
+
+interface CheckBoxItemProps extends Omit<CheckboxFieldProps, "className" | "children" | "style">, StyleProps<"wrapper"> {
+    className?: string;
+    children?: React$1.ReactNode;
+}
+declare function CheckboxItem({ className, classNames, styles, style, children, ...props }: CheckBoxItemProps): React$1.JSX.Element;
+
+type MenuProps = MenuTriggerProps$1;
+declare function Menu({ children, ...props }: MenuProps): React$1.JSX.Element;
+interface MenuTriggerProps {
+    children?: React$1.ReactNode;
+    asChild?: boolean;
+}
+declare function MenuTrigger({ asChild, children }: MenuTriggerProps): React$1.JSX.Element;
+interface MenuContentProps<T extends object = object> extends Omit<MenuProps$1<T>, "className" | "style">, StyleProps<"popover" | "wrapper" | "list"> {
+    menuHeader?: React$1.ReactNode | (() => React$1.ReactNode);
+    menuFooter?: React$1.ReactNode | (() => React$1.ReactNode);
+    minWidth?: number | string;
+    maxHeight?: number | string;
+    maxWidth?: number | string;
+    placement?: Placement;
+    offset?: number;
+    color?: Color;
+}
+declare function MenuContent<T extends object>({ children, menuHeader, menuFooter, minWidth, maxHeight, maxWidth, placement, offset, color, classNames, styles, className, style, ...props }: MenuContentProps<T>): React$1.JSX.Element;
+interface MenuItemProps extends Omit<MenuItemProps$1, "className" | "style" | "children"> {
+    children?: React$1.ReactNode;
+    icon?: React$1.ReactNode;
+    label?: React$1.ReactNode;
+    description?: React$1.ReactNode;
+    color?: Color;
+    isReadOnly?: boolean;
+    className?: string;
+    style?: React$1.CSSProperties;
+}
+declare function MenuItem({ children, icon, label, description, color, isReadOnly, className, style, textValue, ...props }: MenuItemProps): React$1.JSX.Element;
+interface MenuSectionProps<T extends object = object> extends Omit<MenuSectionProps$1<T>, "className" | "children"> {
+    title?: React$1.ReactNode;
+    children?: React$1.ReactNode;
+    className?: string;
+}
+declare function MenuSection<T extends object>({ title, children, className, ...props }: MenuSectionProps<T>): React$1.JSX.Element;
+
+interface ListBoxRenderProps<T> {
+    labelKey?: string;
+    valueKey?: string;
+    sectionKey?: string;
+    color?: Color;
+    width?: number | string;
+    showSectionSeparator?: boolean;
+    showSelectionIndicator?: boolean;
+    renderOption?: (item: T) => React$1.ReactNode;
+    renderSelectionIndicator?: (item: T) => React$1.ReactNode;
+    renderSectionLabel?: (item: T) => React$1.ReactNode;
+    renderEmpty?: () => React$1.ReactNode;
+}
+interface ListBoxProps<T extends object> extends Omit<ListBoxProps$1<T>, "className" | "style" | "children" | "items">, ListBoxRenderProps<T>, StyleProps<"wrapper" | "label" | "section" | "option"> {
+    items?: Iterable<T>;
+    children?: React$1.ReactNode | ((item: T) => React$1.ReactElement);
+    listBoxRef?: React$1.Ref<HTMLDivElement>;
+}
+declare function ListBox<T extends object>({ items, children, labelKey, valueKey, sectionKey, color, width, showSectionSeparator, showSelectionIndicator, renderOption, renderSelectionIndicator, renderSectionLabel, renderEmpty, className, classNames, style, styles, listBoxRef, ...props }: ListBoxProps<T>): React$1.JSX.Element;
+interface ListBoxItemProps extends Omit<ListBoxItemProps$1, "className"> {
+    color?: Color;
+    variant?: ColorVariant;
+    className?: string;
+    showSelectionIndicator?: boolean;
+}
+declare function ListBoxItem({ color, variant, className, showSelectionIndicator, children, textValue, ...props }: ListBoxItemProps): React$1.JSX.Element;
+interface ListBoxSectionProps<T extends object> extends Omit<ListBoxSectionProps$1<T>, "className"> {
+    title?: React$1.ReactNode;
+    className?: string;
+}
+declare function ListBoxSection<T extends object>({ title, className, children, ...props }: ListBoxSectionProps<T>): React$1.JSX.Element;
+
+interface ComboBoxProps<T extends object> extends Pick<ListBoxProps<T>, "labelKey" | "valueKey" | "sectionKey" | "renderOption" | "renderSectionLabel" | "disabledKeys" | "children">, StyleProps<"wrapper" | "input" | "button" | "popover"> {
+    label?: React$1.ReactNode;
+    description?: React$1.ReactNode;
+    error?: React$1.ReactNode;
+    placeholder?: string;
+    prepend?: React$1.ReactNode;
+    append?: React$1.ReactNode;
+    selectorIcon?: React$1.ReactNode;
+    selectorSize?: Size;
+    isLoading?: boolean;
+    loadingIndicator?: React$1.ReactNode;
+    loadData?: (filter?: string, signal?: AbortSignal) => Promise<T[]>;
+    items?: Iterable<T>;
+    defaultItems?: Iterable<T>;
+    inputValue?: string;
+    defaultInputValue?: string;
+    onInputChange?: (value: string) => void;
+    selectedKey?: ID | null;
+    defaultSelectedKey?: ID | null;
+    onSelectionChange?: (key: ID | null) => void;
+    allowsCustomValue?: boolean;
+    menuTrigger?: "focus" | "input" | "manual";
+    isDisabled?: boolean;
+    isRequired?: boolean;
+    color?: Color;
+    size?: "xs" | "sm" | "md" | "lg" | "xl";
+    appearance?: InputAppearance;
+    radius?: Radius;
+}
+declare function ComboBox<T extends object>({ description, error, label, selectorIcon, selectorSize, style, styles, className, classNames, isLoading, loadData, loadingIndicator, items, defaultItems, inputValue, onInputChange, placeholder, prepend, append, color, size, radius, appearance, labelKey, valueKey, sectionKey, renderOption, renderSectionLabel, children, ...props }: ComboBoxProps<T>): React$1.JSX.Element;
+
+interface RadioProps extends Omit<RadioFieldProps, "className" | "style" | "children"> {
+    className?: string;
+    style?: React$1.CSSProperties;
+    size?: "xs" | "sm" | "md" | "lg";
+    appearance?: InputAppearance;
+    color?: Color;
+    children?: React$1.ReactNode;
+}
+declare function Radio({ size, className, style, appearance, color, children, ...props }: RadioProps): React$1.JSX.Element;
+interface RadioGroupProps extends Omit<RadioGroupProps$1, "className" | "style" | "children">, StyleProps<"wrapper"> {
+    children?: React$1.ReactNode;
+    label?: React$1.ReactNode;
+    description?: React$1.ReactNode;
+    errorMessage?: React$1.ReactNode;
+    ref?: React$1.Ref<HTMLDivElement>;
+}
+declare function RadioGroup({ className, classNames, style, styles, label, description, errorMessage, children, ...props }: RadioGroupProps): React$1.JSX.Element;
+
+interface RadioCardProps extends Omit<RadioFieldProps, "className" | "style" | "children">, StyleProps<"wrapper" | "content" | "title" | "description"> {
+    title?: React$1.ReactNode;
+    description?: React$1.ReactNode;
+    children?: React$1.ReactNode;
+    showIndicator?: boolean;
+    appearance?: InputAppearance;
+    color?: Color;
+}
+declare function RadioCard({ title, description, children, appearance, showIndicator, color, className, style, classNames, styles, ...props }: RadioCardProps): React$1.JSX.Element;
+
+interface RadioItemProps extends Omit<RadioFieldProps, "className" | "style" | "children">, StyleProps<"wrapper"> {
+    children?: React$1.ReactNode;
+    className?: string;
+    style?: React$1.CSSProperties;
+}
+declare function RadioItem({ className, style, classNames, styles, children, ...props }: RadioItemProps): React$1.JSX.Element;
+
+type SingleOrMultipleValue = ID | Array<ID>;
+type SelectionMode = "single" | "multiple";
+interface MockNativeOnChangeEvent {
+    target: {
+        value: SingleOrMultipleValue;
+        name?: string;
+    };
+}
+interface SelectProps<T extends object> extends Pick<ListBoxProps<T>, "items" | "labelKey" | "valueKey" | "sectionKey" | "renderOption" | "renderSectionLabel" | "disabledKeys" | "children">, StyleProps<"wrapper" | "trigger" | "value" | "placeholder" | "label" | "popover"> {
+    label?: React$1.ReactNode;
+    description?: React$1.ReactNode;
+    error?: React$1.ReactNode;
+    placeholder?: string;
+    selectionMode?: SelectionMode;
+    value?: SingleOrMultipleValue;
+    defaultValue?: SingleOrMultipleValue;
+    name?: string;
+    isDisabled?: boolean;
+    isRequired?: boolean;
+    color?: Color;
+    listBoxColor?: Color;
+    size?: "xs" | "sm" | "md" | "lg" | "xl";
+    radius?: BorderRadius;
+    appearance?: InputAppearance;
+    showSectionSeparator?: boolean;
+    showSelectionIndicator?: boolean;
+    renderValue?: (value: T) => React$1.ReactNode;
+    onChange?: (event: MockNativeOnChangeEvent) => void;
+    onSelectionChange?: (keys: Array<ID>) => void;
+}
+declare function Select<T extends object>({ label, description, error, placeholder, selectionMode, appearance, renderValue, color, size, radius, listBoxColor, name, value, defaultValue, isDisabled, isRequired, disabledKeys, onChange, onSelectionChange, showSectionSeparator, showSelectionIndicator, items, children, labelKey, valueKey, sectionKey, renderOption, renderSectionLabel, className, classNames, style, styles, }: SelectProps<T>): React$1.JSX.Element;
+
+interface CalendarProps extends Omit<CalendarProps$1<DateValue>, "className" | "style" | "children" | "visibleDuration"> {
+    numberOfMonths?: number;
+    showMonthAndYearPickers?: boolean;
+    color?: Color;
+    radius?: Radius;
+    ref?: React$1.Ref<HTMLDivElement>;
+}
+declare function Calendar({ numberOfMonths, showMonthAndYearPickers, color, radius, ref, ...props }: CalendarProps): React$1.JSX.Element;
+
+interface RangeCalendarProps extends Omit<RangeCalendarProps$1<DateValue>, "className" | "style" | "children" | "visibleDuration"> {
+    numberOfMonths?: number;
+    showMonthAndYearPickers?: boolean;
+    color?: Color;
+    radius?: Radius;
+    ref?: React$1.Ref<HTMLDivElement>;
+}
+declare function RangeCalendar({ numberOfMonths, showMonthAndYearPickers, color, radius, ref, ...props }: RangeCalendarProps): React$1.JSX.Element;
+
+interface DateFieldProps extends Omit<DateFieldProps$1<DateValue>, "value" | "onChange" | "defaultValue" | "className" | "style" | "children">, FieldComponentProps<"input"> {
+    value?: string;
+    defaultValue?: string;
+    onChange?(value: string | null, dateObject?: DateValue | null): void;
+    ref?: React$1.Ref<HTMLDivElement>;
+}
+declare function DateField({ appearance, size, color, radius, value, defaultValue, onChange, label, description, error, validationStatus, prepend, append, className, classNames, style, styles, ref, ...props }: DateFieldProps): React$1.JSX.Element;
+
+interface TimeFieldProps extends Omit<TimeFieldProps$1<TimeValue>, "value" | "onChange" | "defaultValue" | "className" | "style" | "children">, FieldComponentProps<"input"> {
+    value?: string;
+    defaultValue?: string;
+    onChange?(value: string | null, timeObject?: TimeValue | null): void;
+    ref?: React$1.Ref<HTMLDivElement>;
+}
+declare function TimeField({ appearance, size, color, radius, value, defaultValue, onChange, label, description, error, validationStatus, prepend, append, className, classNames, style, styles, ref, ...props }: TimeFieldProps): React$1.JSX.Element;
+
+interface DatePickerProps extends Omit<DatePickerProps$1<DateValue>, "value" | "onChange" | "defaultValue" | "className" | "style" | "children">, FieldComponentProps<"input"> {
+    numberOfMonths?: number;
+    showMonthAndYearPickers?: boolean;
+    value?: string;
+    defaultValue?: string;
+    onChange?(value: string | null, dateObject?: DateValue | null): void;
+    selectorIcon?: React$1.ReactNode;
+    ref?: React$1.Ref<HTMLDivElement>;
+}
+declare function DatePicker({ appearance, size, color, numberOfMonths, showMonthAndYearPickers, radius, selectorIcon, value, defaultValue, onChange, label, description, error, validationStatus, className, classNames, style, styles, ref, ...props }: DatePickerProps): React$1.JSX.Element;
+
+interface DateRangeStrings {
+    start: string;
+    end: string;
+}
+interface DateRangeValue {
+    start: DateValue;
+    end: DateValue;
+}
+interface DateRangePickerProps extends Omit<DateRangePickerProps$1<DateValue>, "value" | "onChange" | "defaultValue" | "className" | "style" | "children">, FieldComponentProps<"input"> {
+    numberOfMonths?: number;
+    showMonthAndYearPickers?: boolean;
+    value?: DateRangeStrings;
+    defaultValue?: DateRangeStrings;
+    onChange?(value: DateRangeStrings | null, range?: DateRangeValue | null): void;
+    dropdownIcon?: React$1.ReactNode;
+    ref?: React$1.Ref<HTMLDivElement>;
+}
+declare function DateRangePicker({ appearance, size, color, numberOfMonths, showMonthAndYearPickers, radius, dropdownIcon, value, defaultValue, onChange, label, description, error, validationStatus, className, classNames, style, styles, ref, ...props }: DateRangePickerProps): React$1.JSX.Element;
+
+type AvatarSize = Size | "2xl" | "3xl";
+interface AvatarProps extends React$1.ComponentPropsWithRef<"div">, StyleProps<"base" | "fallback" | "img"> {
+    src?: string;
+    alt?: string;
+    name?: string;
+    fallback?: React$1.ReactNode;
+    radius?: Radius;
+    color?: Color;
+    variant?: Variant;
+    size?: AvatarSize;
+    getInitials?: (name: string) => string;
+}
+declare function Avatar({ src, alt, name, color, variant, fallback, children, size, className, radius, classNames, styles, style, getInitials, ref, ...props }: AvatarProps): React$1.JSX.Element;
+interface AvatarGroupProps extends StyleProps<"wrapper" | "overflow"> {
+    max?: number;
+    size?: AvatarSize;
+    color?: Color;
+    variant?: Variant;
+    children?: React$1.ReactNode;
+}
+declare function AvatarGroup({ max, size, color, variant, children, className, style, classNames, styles, }: AvatarGroupProps): React$1.JSX.Element;
+
+type Upload = {
+    name: string;
+    url: string;
+    id: string;
+    file?: File;
+    status?: ActionStatus;
+    progress?: number;
+};
+interface FileUploaderProps extends StyleProps<"wrapper" | "dropzone" | "list"> {
+    onFileUpload?: (files: Array<Upload>) => void;
+    onRemoveFile?: () => void;
+    onStatusChange?: (status: ActionStatus) => void;
+    error?: React$1.ReactNode;
+    label?: React$1.ReactNode;
+    allowMultiple?: boolean;
+    uploads?: Array<Upload>;
+    hideFileList?: boolean;
+    color?: Color;
+    ref?: React$1.Ref<HTMLDivElement>;
+}
+declare function FileUploader({ onFileUpload, onRemoveFile, error, label, allowMultiple, uploads: controlledUploads, hideFileList, color, ref, classNames, styles, className, style, }: FileUploaderProps): React$1.JSX.Element;
+
+interface SeparatorProps extends React$1.ComponentPropsWithRef<"div"> {
+    orientation?: "horizontal" | "vertical";
+    color?: Color;
+    opacity?: "faint" | "medium" | "strong";
+}
+declare function Separator({ orientation, className, color, opacity, ref, ...props }: SeparatorProps): React$1.JSX.Element;
+
+interface ProgressProps extends Omit<ProgressBarProps, "className" | "style" | "children">, StyleProps<"wrapper" | "track" | "bar" | "label"> {
+    height?: number;
+    color?: Color;
+    label?: React$1.ReactNode;
+    ref?: React$1.Ref<HTMLDivElement>;
+}
+declare function Progress({ height, className, style, classNames, styles, color, label, ref, ...props }: ProgressProps): React$1.JSX.Element;
+
+interface LoaderProps extends Omit<React$1.ComponentPropsWithRef<"div">, "color">, StyleProps<"wrapper" | "icon"> {
+    size?: "xs" | "sm" | "md" | "lg" | "xl" | "2xl" | "3xl";
+    color?: Color;
+    label?: string;
+}
+declare function Loader({ color, className, classNames, style, styles, size, label, ref, ...props }: LoaderProps): React$1.JSX.Element;
+
+type TagProps = Omit<React__default.ComponentPropsWithRef<"span">, "className" | "style"> & StyleProps<"wrapper"> & {
+    prepend?: React__default.ReactNode;
+    append?: React__default.ReactNode;
+    hashValue?: string;
+    color?: Color;
+    size?: "xs" | "sm" | "md" | "lg" | "xl";
+    /**@deprecated use radius instead */
+    shape?: "pill" | "rounded" | "sharp";
+    radius?: BorderRadius;
+    variant?: ColorVariant;
+};
+declare function Tag({ prepend, append, children, hashValue, color, size, shape, variant, className, style, classNames, styles, radius, ref, ...props }: TagProps): React__default.JSX.Element;
+
+interface SwitchProps extends Omit<SwitchFieldProps, "className" | "style" | "children">, StyleProps<"wrapper" | "thumb"> {
+    color?: Color;
+    size?: "sm" | "md" | "lg";
+    children?: React$1.ReactNode;
+}
+declare function Switch({ color, size, children, className, style, classNames, styles, ...props }: SwitchProps): React$1.JSX.Element;
+
+type SliderProps = {
+    name?: string;
+    size?: SizeOption;
+    color?: Color;
+    label?: React$1.ReactNode;
+} & StyleProps<"wrapper" | "track" | "fill" | "thumb" | "innerThumb" | "label"> & Omit<SliderProps$1, "className" | "style" | "children">;
+declare function Slider({ className, classNames, style, styles, name, size, color, label, orientation, ...props }: SliderProps): React$1.JSX.Element;
+
+interface StickerProps extends React__default.ComponentPropsWithRef<"div"> {
+    padded?: boolean;
+    color?: Color;
+    variant?: Variant;
+    radius?: Radius;
+}
+declare function Sticker({ variant, color, padded, radius, children, ref, className, style, ...props }: StickerProps): React__default.JSX.Element;
+
+interface TabsProps extends Omit<TabsProps$1, "className" | "style" | "children">, StyleProps<"wrapper" | "list" | "tab" | "indicator" | "panel"> {
+    children?: React$1.ReactNode;
+}
+interface TabProps {
+    id?: Key;
+    title: React$1.ReactNode;
+    children?: React$1.ReactNode;
+    isDisabled?: boolean;
+}
+declare function Tab(_props: TabProps): null;
+declare function Tabs({ className, style, classNames, styles, children, onSelectionChange, ...props }: TabsProps): React$1.JSX.Element;
+
+interface TableColumn<T extends Dict<any> = object> {
+    title?: string;
+    dataIndex: keyof T;
+    key: ID;
+    render?(value: T[keyof T], item: T): React.ReactNode;
+    allowSorting?: boolean;
+}
+
+interface TableProps<T extends object> extends StyleProps<"wrapper" | "header" | "column" | "row" | "cell"> {
+    columns: Array<TableColumn<T>>;
+    data: Array<T>;
+    radius?: Radius;
+    getRowId?: (item: T) => string | number;
+    selectionMode?: "none" | "single" | "multiple";
+    selectedKeys?: Selection;
+    onSelectionChange?: (keys: Selection) => void;
+    sortDescriptor?: SortDescriptor;
+    onSortChange?: (descriptor: SortDescriptor) => void;
+    renderEmptyState?: () => React$1.ReactNode;
+    "aria-label"?: string;
+}
+declare function Table<T extends object>({ columns, data, getRowId, selectionMode, selectedKeys, onSelectionChange, sortDescriptor, onSortChange, renderEmptyState, radius, className, classNames, style, styles, ...props }: TableProps<T>): React$1.JSX.Element;
+
+interface TimelineProps<T> extends StyleProps<"wrapper" | "item" | "content"> {
+    items: Array<T>;
+    render?(item: T): React__default.ReactNode;
+    labelKey?: keyof T;
+    getIndicator?(item: T): React__default.ReactNode;
+    hideLastItemTail?: boolean;
+}
+declare function Timeline<T>({ items, render, labelKey, getIndicator, hideLastItemTail, classNames, styles, className, style, }: TimelineProps<T>): React__default.JSX.Element;
+
+interface ModalProps extends Omit<ModalOverlayProps, "children" | "className" | "style">, StyleProps<"wrapper" | "underlay" | "content" | "header" | "body" | "footer" | "title"> {
+    hideTitle?: boolean;
+    children?: React$1.ReactNode;
+    title?: React$1.ReactNode;
+    description?: React$1.ReactNode;
+    onConfirm?(): void;
+    onCancel?(): void;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    confirmButtonProps?: React$1.ComponentProps<typeof Button>;
+    cancelButtonProps?: React$1.ComponentProps<typeof Button>;
+    width?: number | string;
+    variant?: "modal" | "drawer";
+    radius?: Radius;
+    showCloseButton?: boolean;
+    onClose?(): void;
+}
+declare function Modal({ variant, radius, isDismissable, width, title, description, onConfirm, onCancel, confirmLabel, cancelLabel, confirmButtonProps, cancelButtonProps, showCloseButton, hideTitle, onClose, children, className, style, classNames, styles, ...props }: ModalProps): React$1.JSX.Element;
+declare function useModal(props?: OverlayTriggerProps): react_aria_components.OverlayTriggerState;
+
+type TagFormat = "text" | "email" | "url" | "number";
+interface TagInputProps extends FieldComponentProps<"input"> {
+    tags?: Array<string>;
+    defaultTags?: Array<string>;
+    placeholder?: string;
+    /** Built-in validation preset for committed values. Defaults to "text". */
+    format?: TagFormat;
+    /** Custom validator; overrides `format` when provided. */
+    validate?: (value: string) => boolean;
+    /** Characters that commit the current input into a tag. Defaults to [","]. */
+    delimiters?: Array<string>;
+    isRequired?: boolean;
+    onInputValueChange?(value: string): void;
+    onChange?(tags: Array<string>): void;
+    tagVariant?: React$1.ComponentProps<typeof Tag>["variant"];
+    tagColor?: React$1.ComponentProps<typeof Tag>["color"];
+    tagShape?: React$1.ComponentProps<typeof Tag>["shape"];
+    tagSize?: React$1.ComponentProps<typeof Tag>["size"];
+    renderTag?(value: string, onRemove: (value: string) => void): React$1.ReactNode;
+    ref?: React$1.Ref<HTMLDivElement>;
+}
+declare function TagInput({ appearance, size, label, error, description, placeholder, tags, defaultTags, format, validate, delimiters, isRequired, tagColor, tagVariant, tagShape, tagSize, color, radius, validationStatus, className, classNames, style, styles, onChange, onInputValueChange, renderTag, ref, }: TagInputProps): React$1.JSX.Element;
+
+interface PopoverProps extends OverlayTriggerProps {
+    children?: React$1.ReactNode;
+}
+declare function Popover({ children, ...props }: PopoverProps): React$1.JSX.Element;
+interface PopoverTriggerProps {
+    children: React$1.ReactElement;
+}
+declare function PopoverTrigger({ children }: PopoverTriggerProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+interface PopoverContentProps extends StyleProps<"popover" | "content">, Omit<PopoverProps$1, "triggerRef" | "children" | "className" | "style" | "isOpen" | "defaultOpen" | "onOpenChange"> {
+    children?: React$1.ReactNode;
+    width?: number;
+}
+declare function PopoverContent({ children, offset, placement, style, className, classNames, styles, width, ...props }: PopoverContentProps): React$1.JSX.Element;
+
+interface TagVariantProps {
+    activeColor?: Color;
+    activeVariant?: Variant;
+    idleColor?: Color;
+    idleVariant?: Variant;
+    autoColor?: boolean;
+}
+interface TagGroupProps<T extends object> extends Omit<TagGroupProps$1, "className" | "style" | "children">, Pick<TagListProps<T>, "items" | "children" | "renderEmptyState">, TagVariantProps, StyleProps<"wrapper" | "list"> {
+    label?: React$1.ReactNode;
+    description?: React$1.ReactNode;
+    errorMessage?: React$1.ReactNode;
+}
+declare function TagGroup<T extends object>({ label, description, errorMessage, items, children, renderEmptyState, activeColor, activeVariant, idleColor, idleVariant, autoColor, classNames, styles, className, style, ...props }: TagGroupProps<T>): React$1.JSX.Element;
+interface TagGroupItemProps extends Omit<TagProps$1, "className" | "children" | "render"> {
+    children?: React$1.ReactNode;
+}
+declare function TagGroupItem({ children, textValue, ...props }: TagGroupItemProps): React$1.JSX.Element;
+
+interface ThemeProviderValue {
+    color?: Color;
+    radius?: BorderRadius;
+    appearance?: Appearance;
+    buttonAppearance?: ButtonAppearanceSchemaType;
+    avatarRadiusSize?: BorderRadius;
+    inputAppearance?: InputAppearance;
+}
+interface ThemeProviderProps extends ThemeProviderValue {
+    children?: React$1.ReactNode;
+    className?: string;
+}
+declare function ThemeProvider(props: ThemeProviderProps): React$1.JSX.Element;
+declare function useTheme(options?: {
+    requireThemeProvider: boolean;
+}): ThemeProviderValue | null;
+
+type ColorPickerProps = StyleProps<"wrapper" | "area" | "swatch" | "hue" | "alpha"> & {
+    onChange?: (color: Color$1) => void;
+    color?: Color$1;
+};
+declare function ColorPicker({ onChange, color: colorProp, styles, classNames, className, style, }: ColorPickerProps): React$1.JSX.Element;
+
+type ColorAreaProps = Omit<ColorAreaProps$1, "className" | "style"> & StyleProps<"wrapper" | "thumb"> & {
+    size?: SizeOption;
+    radius?: BorderRadius;
+};
+declare function ColorArea({ className, classNames, style, styles, radius, ...props }: ColorAreaProps): React$1.JSX.Element;
+
+type ColorFieldProps = Omit<ColorFieldProps$1, "className" | "style" | "children"> & FieldComponentProps<"input"> & {
+    placeholder?: string;
+};
+declare function ColorField({ className, classNames, style, styles, inputRef, wrapperRef, prepend, append, label, description, error, color, size, radius, appearance, validationStatus, shape, placeholder, ...colorFieldProps }: ColorFieldProps): React$1.JSX.Element;
+
+interface ColorOption {
+    key?: string;
+    color: string;
+    label?: string;
+}
+type ColorSwatchPickerProps = Omit<ColorSwatchPickerProps$1, "className" | "style" | "children" | "onChange"> & StyleProps<"wrapper" | "swatch"> & {
+    colors: Array<ColorOption>;
+    onChange?: (color: Color$1) => void;
+    size?: SizeOption;
+    radius?: BorderRadius;
+};
+declare function ColorSwatchPicker({ colors, size, radius, onChange, className, classNames, style, styles, ...props }: ColorSwatchPickerProps): React$1.JSX.Element;
+
+type ColorSliderProps = Omit<ColorSliderProps$1, "className" | "style" | "children"> & {
+    label?: React$1.ReactNode;
+};
+declare function ColorSlider({ label, ...props }: ColorSliderProps): React$1.JSX.Element;
+
+declare function parseColor(color: string): react_aria_components.Color;
+
+type Mode = "single" | "multiple";
+type ValueType<M> = M extends "multiple" ? string[] : string;
+interface ToggleGroupProps<M extends Mode> extends StyleProps<"wrapper">, ButtonToggleProps {
+    selectionMode?: M;
+    value?: ValueType<M>;
+    defaultValue?: ValueType<M>;
+    onChange?: (value: ValueType<M>) => void;
+    label?: string;
+    size?: ButtonSize;
+    radius?: BorderRadius;
+    disallowEmptySelection?: boolean;
+    orientation?: "horizontal" | "vertical";
+    children?: React$1.ReactNode;
+    compact?: boolean;
+    gap?: React$1.ComponentProps<typeof Space>["gap"];
+}
+declare function ToggleGroup<M extends Mode = "single">({ selectionMode, value, defaultValue, onChange, label, size, radius, idleColor, idleVariant, activeColor, activeVariant, disallowEmptySelection, orientation, compact, gap, className, classNames, style, styles, children, }: ToggleGroupProps<M>): React$1.JSX.Element;
+interface ToggleProps extends ButtonToggleProps, StyleProps<"wrapper"> {
+    value: string;
+    children: React$1.ReactNode;
+    size?: ButtonSize;
+    radius?: BorderRadius;
+    isIconButton?: boolean;
+}
+declare function Toggle({ value, ...props }: ToggleProps): React$1.JSX.Element;
+
+export { Avatar, AvatarGroup, Button, ButtonGroup, Calendar, Checkbox, CheckboxGroup, CheckboxItem, ColorArea, ColorField, ColorPicker, ColorSlider, ColorSwatchPicker, ComboBox, DateField, DatePicker, DateRangePicker, FileUploader, IconButton, Input, ListBox, ListBoxItem, ListBoxSection, Loader, Menu, MenuContent, MenuItem, MenuSection, MenuTrigger, Modal, type ModalProps, NumberInput, ListBoxItem as Option, Popover, PopoverContent, PopoverTrigger, Progress, Radio, RadioCard, RadioGroup, RadioItem, RangeCalendar, ListBoxSection as Section, Select, Separator, Slider, Space, Sticker, Switch, Tab, Table, Tabs, Tag, TagGroup, TagGroupItem, TagInput, Text, Textarea, ThemeProvider, TimeField, Timeline, Toggle, ToggleButton, ToggleGroup, parseColor, useModal, useTheme };