@structyl/primitives 1.0.0

package/dist/index.d.cts

@@ -0,0 +1,4416 @@
+import * as React from 'react';
+import * as _structyl_core from '@structyl/core';
+import { PointerDownOutsideEvent, FocusOutsideEvent } from '@structyl/core';
+
+interface ButtonProps$1 extends React.ComponentPropsWithoutRef<'button'> {
+    asChild?: boolean;
+    loading?: boolean;
+    loadingText?: string;
+}
+declare const Button$1: React.ForwardRefExoticComponent<ButtonProps$1 & React.RefAttributes<HTMLButtonElement>>;
+
+interface RatingProps$1 extends Omit<React.ComponentPropsWithoutRef<'div'>, 'onChange'> {
+    value?: number;
+    defaultValue?: number;
+    onChange?: (value: number) => void;
+    max?: number;
+    step?: number;
+    disabled?: boolean;
+    readOnly?: boolean;
+    required?: boolean;
+    name?: string;
+    id?: string;
+}
+declare const Rating$1: React.ForwardRefExoticComponent<RatingProps$1 & React.RefAttributes<HTMLDivElement>>;
+
+interface DialogRootProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    modal?: boolean;
+    children?: React.ReactNode;
+}
+interface DialogTriggerProps extends React.ComponentPropsWithoutRef<'button'> {
+    asChild?: boolean;
+}
+interface DialogPortalProps {
+    children?: React.ReactNode;
+    container?: Element | DocumentFragment | null;
+    forceMount?: boolean;
+}
+interface DialogOverlayProps extends React.ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+    forceMount?: boolean;
+}
+interface DialogContentProps extends React.ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+    forceMount?: boolean;
+    onEscapeKeyDown?: (event: KeyboardEvent) => void;
+    onPointerDownOutside?: (event: PointerDownOutsideEvent) => void;
+    onInteractOutside?: (event: PointerDownOutsideEvent | FocusOutsideEvent) => void;
+    onOpenAutoFocus?: (event: Event) => void;
+    onCloseAutoFocus?: (event: Event) => void;
+}
+interface DialogTitleProps extends React.ComponentPropsWithoutRef<'h2'> {
+    asChild?: boolean;
+}
+interface DialogDescriptionProps extends React.ComponentPropsWithoutRef<'p'> {
+    asChild?: boolean;
+}
+interface DialogCloseProps extends React.ComponentPropsWithoutRef<'button'> {
+    asChild?: boolean;
+}
+
+declare const Root$H: React.FC<DialogRootProps>;
+declare const Trigger$i: React.ForwardRefExoticComponent<DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const Portal$g: React.FC<DialogPortalProps>;
+declare const Overlay$1: React.ForwardRefExoticComponent<DialogOverlayProps & React.RefAttributes<HTMLDivElement>>;
+declare const Content$j: React.ForwardRefExoticComponent<DialogContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const Title$3: React.ForwardRefExoticComponent<DialogTitleProps & React.RefAttributes<HTMLHeadingElement>>;
+declare const Description$3: React.ForwardRefExoticComponent<DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>>;
+declare const Close$2: React.ForwardRefExoticComponent<DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+
+type index$L_DialogCloseProps = DialogCloseProps;
+type index$L_DialogContentProps = DialogContentProps;
+type index$L_DialogDescriptionProps = DialogDescriptionProps;
+type index$L_DialogOverlayProps = DialogOverlayProps;
+type index$L_DialogPortalProps = DialogPortalProps;
+type index$L_DialogRootProps = DialogRootProps;
+type index$L_DialogTitleProps = DialogTitleProps;
+type index$L_DialogTriggerProps = DialogTriggerProps;
+declare namespace index$L {
+  export { Close$2 as Close, Content$j as Content, Description$3 as Description, type index$L_DialogCloseProps as DialogCloseProps, type index$L_DialogContentProps as DialogContentProps, type index$L_DialogDescriptionProps as DialogDescriptionProps, type index$L_DialogOverlayProps as DialogOverlayProps, type index$L_DialogPortalProps as DialogPortalProps, type index$L_DialogRootProps as DialogRootProps, type index$L_DialogTitleProps as DialogTitleProps, type index$L_DialogTriggerProps as DialogTriggerProps, Overlay$1 as Overlay, Portal$g as Portal, Root$H as Root, Title$3 as Title, Trigger$i as Trigger };
+}
+
+type ImageLoadingStatus = 'idle' | 'loading' | 'loaded' | 'error';
+interface AvatarRootProps extends React.ComponentPropsWithoutRef<'span'> {
+    asChild?: boolean;
+}
+interface AvatarImageProps extends React.ComponentPropsWithoutRef<'img'> {
+    asChild?: boolean;
+    onLoadingStatusChange?: (status: ImageLoadingStatus) => void;
+}
+interface AvatarFallbackProps extends React.ComponentPropsWithoutRef<'span'> {
+    asChild?: boolean;
+    /** Delay in ms before the fallback is shown, to avoid flicker on fast image loads. */
+    delayMs?: number;
+}
+
+declare const Root$G: React.ForwardRefExoticComponent<AvatarRootProps & React.RefAttributes<HTMLSpanElement>>;
+declare const Image: React.ForwardRefExoticComponent<AvatarImageProps & React.RefAttributes<HTMLImageElement>>;
+declare const Fallback: React.ForwardRefExoticComponent<AvatarFallbackProps & React.RefAttributes<HTMLSpanElement>>;
+
+type index$K_AvatarFallbackProps = AvatarFallbackProps;
+type index$K_AvatarImageProps = AvatarImageProps;
+type index$K_AvatarRootProps = AvatarRootProps;
+declare const index$K_Fallback: typeof Fallback;
+declare const index$K_Image: typeof Image;
+type index$K_ImageLoadingStatus = ImageLoadingStatus;
+declare namespace index$K {
+  export { type index$K_AvatarFallbackProps as AvatarFallbackProps, type index$K_AvatarImageProps as AvatarImageProps, type index$K_AvatarRootProps as AvatarRootProps, index$K_Fallback as Fallback, index$K_Image as Image, type index$K_ImageLoadingStatus as ImageLoadingStatus, Root$G as Root };
+}
+
+type ProgressState = 'indeterminate' | 'loading' | 'complete';
+interface ProgressRootProps extends React.ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+    /** Current progress value (0 to max). Pass `null` for indeterminate. */
+    value?: number | null;
+    /** Maximum value. */
+    max?: number;
+    /** Returns the localized label to announce. */
+    getValueLabel?: (value: number, max: number) => string;
+}
+interface ProgressIndicatorProps extends React.ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+}
+
+declare const Root$F: React.ForwardRefExoticComponent<ProgressRootProps & React.RefAttributes<HTMLDivElement>>;
+declare const Indicator$2: React.ForwardRefExoticComponent<ProgressIndicatorProps & React.RefAttributes<HTMLDivElement>>;
+
+type index$J_ProgressIndicatorProps = ProgressIndicatorProps;
+type index$J_ProgressRootProps = ProgressRootProps;
+type index$J_ProgressState = ProgressState;
+declare namespace index$J {
+  export { Indicator$2 as Indicator, type index$J_ProgressIndicatorProps as ProgressIndicatorProps, type index$J_ProgressRootProps as ProgressRootProps, type index$J_ProgressState as ProgressState, Root$F as Root };
+}
+
+interface RadioGroupRootProps extends Omit<React.ComponentPropsWithoutRef<'div'>, 'onChange'> {
+    asChild?: boolean;
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    disabled?: boolean;
+    required?: boolean;
+    name?: string;
+    orientation?: 'horizontal' | 'vertical';
+    dir?: 'ltr' | 'rtl';
+    loop?: boolean;
+}
+interface RadioGroupItemProps extends React.ComponentPropsWithoutRef<'button'> {
+    asChild?: boolean;
+    value: string;
+    disabled?: boolean;
+    required?: boolean;
+}
+interface RadioGroupIndicatorProps extends React.ComponentPropsWithoutRef<'span'> {
+    asChild?: boolean;
+    forceMount?: boolean;
+}
+
+declare const Root$E: React.ForwardRefExoticComponent<RadioGroupRootProps & React.RefAttributes<HTMLDivElement>>;
+declare const Item$e: React.ForwardRefExoticComponent<RadioGroupItemProps & React.RefAttributes<HTMLButtonElement>>;
+declare const Indicator$1: React.ForwardRefExoticComponent<RadioGroupIndicatorProps & React.RefAttributes<HTMLSpanElement>>;
+
+type index$I_RadioGroupIndicatorProps = RadioGroupIndicatorProps;
+type index$I_RadioGroupItemProps = RadioGroupItemProps;
+type index$I_RadioGroupRootProps = RadioGroupRootProps;
+declare namespace index$I {
+  export { Indicator$1 as Indicator, Item$e as Item, type index$I_RadioGroupIndicatorProps as RadioGroupIndicatorProps, type index$I_RadioGroupItemProps as RadioGroupItemProps, type index$I_RadioGroupRootProps as RadioGroupRootProps, Root$E as Root };
+}
+
+interface CommonRootProps$1 extends Omit<React.ComponentPropsWithoutRef<'div'>, 'onChange'> {
+    asChild?: boolean;
+    disabled?: boolean;
+    rovingFocus?: boolean;
+    orientation?: 'horizontal' | 'vertical';
+    dir?: 'ltr' | 'rtl';
+    loop?: boolean;
+}
+interface ToggleGroupSingleProps extends CommonRootProps$1 {
+    type: 'single';
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+}
+interface ToggleGroupMultipleProps extends CommonRootProps$1 {
+    type: 'multiple';
+    value?: string[];
+    defaultValue?: string[];
+    onValueChange?: (value: string[]) => void;
+}
+type ToggleGroupRootProps = ToggleGroupSingleProps | ToggleGroupMultipleProps;
+interface ToggleGroupItemProps extends React.ComponentPropsWithoutRef<'button'> {
+    asChild?: boolean;
+    value: string;
+    disabled?: boolean;
+}
+
+declare const Root$D: React.ForwardRefExoticComponent<ToggleGroupRootProps & React.RefAttributes<HTMLDivElement>>;
+declare const Item$d: React.ForwardRefExoticComponent<ToggleGroupItemProps & React.RefAttributes<HTMLButtonElement>>;
+
+type index$H_ToggleGroupItemProps = ToggleGroupItemProps;
+type index$H_ToggleGroupMultipleProps = ToggleGroupMultipleProps;
+type index$H_ToggleGroupRootProps = ToggleGroupRootProps;
+type index$H_ToggleGroupSingleProps = ToggleGroupSingleProps;
+declare namespace index$H {
+  export { Item$d as Item, Root$D as Root, type index$H_ToggleGroupItemProps as ToggleGroupItemProps, type index$H_ToggleGroupMultipleProps as ToggleGroupMultipleProps, type index$H_ToggleGroupRootProps as ToggleGroupRootProps, type index$H_ToggleGroupSingleProps as ToggleGroupSingleProps };
+}
+
+interface SliderRootProps extends Omit<React.ComponentPropsWithoutRef<'span'>, 'defaultValue' | 'value' | 'onChange'> {
+    asChild?: boolean;
+    name?: string;
+    disabled?: boolean;
+    orientation?: 'horizontal' | 'vertical';
+    dir?: 'ltr' | 'rtl';
+    min?: number;
+    max?: number;
+    step?: number;
+    /** Smallest gap between thumbs in multi-thumb sliders. */
+    minStepsBetweenThumbs?: number;
+    value?: number[];
+    defaultValue?: number[];
+    onValueChange?: (value: number[]) => void;
+    onValueCommit?: (value: number[]) => void;
+    inverted?: boolean;
+}
+interface SliderTrackProps extends React.ComponentPropsWithoutRef<'span'> {
+    asChild?: boolean;
+}
+interface SliderRangeProps extends React.ComponentPropsWithoutRef<'span'> {
+    asChild?: boolean;
+}
+interface SliderThumbProps extends React.ComponentPropsWithoutRef<'span'> {
+    asChild?: boolean;
+}
+
+declare const Root$C: React.ForwardRefExoticComponent<SliderRootProps & React.RefAttributes<HTMLSpanElement>>;
+declare const Track: React.ForwardRefExoticComponent<SliderTrackProps & React.RefAttributes<HTMLSpanElement>>;
+declare const Range: React.ForwardRefExoticComponent<SliderRangeProps & React.RefAttributes<HTMLSpanElement>>;
+declare const Thumb$1: React.ForwardRefExoticComponent<SliderThumbProps & React.RefAttributes<HTMLSpanElement>>;
+
+declare const index$G_Range: typeof Range;
+type index$G_SliderRangeProps = SliderRangeProps;
+type index$G_SliderRootProps = SliderRootProps;
+type index$G_SliderThumbProps = SliderThumbProps;
+type index$G_SliderTrackProps = SliderTrackProps;
+declare const index$G_Track: typeof Track;
+declare namespace index$G {
+  export { index$G_Range as Range, Root$C as Root, type index$G_SliderRangeProps as SliderRangeProps, type index$G_SliderRootProps as SliderRootProps, type index$G_SliderThumbProps as SliderThumbProps, type index$G_SliderTrackProps as SliderTrackProps, Thumb$1 as Thumb, index$G_Track as Track };
+}
+
+type ValidityMatcher = 'badInput' | 'patternMismatch' | 'rangeOverflow' | 'rangeUnderflow' | 'stepMismatch' | 'tooLong' | 'tooShort' | 'typeMismatch' | 'valid' | 'valueMissing';
+type CustomMatcher = string;
+type Matcher = ValidityMatcher | CustomMatcher;
+interface FormProps extends React.ComponentPropsWithoutRef<'form'> {
+    asChild?: boolean;
+    /** Map of field name → server-side validity errors. */
+    onClearServerErrors?: () => void;
+}
+interface FormFieldProps extends React.ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+    name: string;
+    serverInvalid?: boolean;
+}
+interface FormLabelProps extends React.ComponentPropsWithoutRef<'label'> {
+    asChild?: boolean;
+}
+interface FormControlProps extends React.ComponentPropsWithoutRef<'input'> {
+    asChild?: boolean;
+}
+interface FormMessageProps extends React.ComponentPropsWithoutRef<'span'> {
+    asChild?: boolean;
+    match?: Matcher | ((value: string, formData: FormData) => boolean | Promise<boolean>);
+    forceMatch?: boolean;
+}
+interface FormValidityStateProps {
+    children: (validity: ValidityState | undefined) => React.ReactNode;
+}
+interface FormSubmitProps extends React.ComponentPropsWithoutRef<'button'> {
+    asChild?: boolean;
+}
+
+declare const Form: React.ForwardRefExoticComponent<FormProps & React.RefAttributes<HTMLFormElement>>;
+declare const Field: React.ForwardRefExoticComponent<FormFieldProps & React.RefAttributes<HTMLDivElement>>;
+declare const Label$7: React.ForwardRefExoticComponent<FormLabelProps & React.RefAttributes<HTMLLabelElement>>;
+declare const Control: React.ForwardRefExoticComponent<FormControlProps & React.RefAttributes<HTMLInputElement>>;
+declare const Message: React.ForwardRefExoticComponent<FormMessageProps & React.RefAttributes<HTMLSpanElement>>;
+declare const ValidityState$1: React.FC<FormValidityStateProps>;
+declare const Submit: React.ForwardRefExoticComponent<FormSubmitProps & React.RefAttributes<HTMLButtonElement>>;
+
+declare const index$F_Control: typeof Control;
+type index$F_CustomMatcher = CustomMatcher;
+declare const index$F_Field: typeof Field;
+type index$F_FormControlProps = FormControlProps;
+type index$F_FormFieldProps = FormFieldProps;
+type index$F_FormLabelProps = FormLabelProps;
+type index$F_FormMessageProps = FormMessageProps;
+type index$F_FormProps = FormProps;
+type index$F_FormSubmitProps = FormSubmitProps;
+type index$F_FormValidityStateProps = FormValidityStateProps;
+type index$F_Matcher = Matcher;
+declare const index$F_Message: typeof Message;
+declare const index$F_Submit: typeof Submit;
+type index$F_ValidityMatcher = ValidityMatcher;
+declare namespace index$F {
+  export { index$F_Control as Control, type index$F_CustomMatcher as CustomMatcher, index$F_Field as Field, type index$F_FormControlProps as FormControlProps, type index$F_FormFieldProps as FormFieldProps, type index$F_FormLabelProps as FormLabelProps, type index$F_FormMessageProps as FormMessageProps, type index$F_FormProps as FormProps, type index$F_FormSubmitProps as FormSubmitProps, type index$F_FormValidityStateProps as FormValidityStateProps, Label$7 as Label, type index$F_Matcher as Matcher, index$F_Message as Message, Form as Root, index$F_Submit as Submit, type index$F_ValidityMatcher as ValidityMatcher, ValidityState$1 as ValidityState };
+}
+
+interface CollapsibleRootProps extends Omit<React.ComponentPropsWithoutRef<'div'>, 'onChange'> {
+    asChild?: boolean;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    disabled?: boolean;
+}
+interface CollapsibleTriggerProps extends React.ComponentPropsWithoutRef<'button'> {
+    asChild?: boolean;
+}
+interface CollapsibleContentProps extends React.ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+    forceMount?: boolean;
+}
+
+declare const Root$B: React.ForwardRefExoticComponent<CollapsibleRootProps & React.RefAttributes<HTMLDivElement>>;
+declare const Trigger$h: React.ForwardRefExoticComponent<CollapsibleTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const Content$i: React.ForwardRefExoticComponent<CollapsibleContentProps & React.RefAttributes<HTMLDivElement>>;
+
+type index$E_CollapsibleContentProps = CollapsibleContentProps;
+type index$E_CollapsibleRootProps = CollapsibleRootProps;
+type index$E_CollapsibleTriggerProps = CollapsibleTriggerProps;
+declare namespace index$E {
+  export { type index$E_CollapsibleContentProps as CollapsibleContentProps, type index$E_CollapsibleRootProps as CollapsibleRootProps, type index$E_CollapsibleTriggerProps as CollapsibleTriggerProps, Content$i as Content, Root$B as Root, Trigger$h as Trigger };
+}
+
+interface CommonRootProps extends Omit<React.ComponentPropsWithoutRef<'div'>, 'onChange'> {
+    asChild?: boolean;
+    disabled?: boolean;
+    orientation?: 'horizontal' | 'vertical';
+    dir?: 'ltr' | 'rtl';
+}
+interface AccordionSingleProps extends CommonRootProps {
+    type: 'single';
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    collapsible?: boolean;
+}
+interface AccordionMultipleProps extends CommonRootProps {
+    type: 'multiple';
+    value?: string[];
+    defaultValue?: string[];
+    onValueChange?: (value: string[]) => void;
+}
+type AccordionRootProps = AccordionSingleProps | AccordionMultipleProps;
+interface AccordionItemProps extends React.ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+    value: string;
+    disabled?: boolean;
+}
+interface AccordionHeaderProps extends React.ComponentPropsWithoutRef<'h3'> {
+    asChild?: boolean;
+}
+interface AccordionTriggerProps extends React.ComponentPropsWithoutRef<'button'> {
+    asChild?: boolean;
+}
+interface AccordionContentProps extends React.ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+    forceMount?: boolean;
+}
+
+declare const Root$A: React.ForwardRefExoticComponent<AccordionRootProps & React.RefAttributes<HTMLDivElement>>;
+declare const Item$c: React.ForwardRefExoticComponent<AccordionItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const Header$2: React.ForwardRefExoticComponent<AccordionHeaderProps & React.RefAttributes<HTMLHeadingElement>>;
+declare const Trigger$g: React.ForwardRefExoticComponent<AccordionTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const Content$h: React.ForwardRefExoticComponent<AccordionContentProps & React.RefAttributes<HTMLDivElement>>;
+
+type index$D_AccordionContentProps = AccordionContentProps;
+type index$D_AccordionHeaderProps = AccordionHeaderProps;
+type index$D_AccordionItemProps = AccordionItemProps;
+type index$D_AccordionMultipleProps = AccordionMultipleProps;
+type index$D_AccordionRootProps = AccordionRootProps;
+type index$D_AccordionSingleProps = AccordionSingleProps;
+type index$D_AccordionTriggerProps = AccordionTriggerProps;
+declare namespace index$D {
+  export { type index$D_AccordionContentProps as AccordionContentProps, type index$D_AccordionHeaderProps as AccordionHeaderProps, type index$D_AccordionItemProps as AccordionItemProps, type index$D_AccordionMultipleProps as AccordionMultipleProps, type index$D_AccordionRootProps as AccordionRootProps, type index$D_AccordionSingleProps as AccordionSingleProps, type index$D_AccordionTriggerProps as AccordionTriggerProps, Content$h as Content, Header$2 as Header, Item$c as Item, Root$A as Root, Trigger$g as Trigger };
+}
+
+interface TabsRootProps extends Omit<React.ComponentPropsWithoutRef<'div'>, 'onChange'> {
+    asChild?: boolean;
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    orientation?: 'horizontal' | 'vertical';
+    dir?: 'ltr' | 'rtl';
+    /** When set, focusing a tab activates it. 'manual' requires Enter/Space. */
+    activationMode?: 'automatic' | 'manual';
+}
+interface TabsListProps extends React.ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+    loop?: boolean;
+}
+interface TabsTriggerProps extends React.ComponentPropsWithoutRef<'button'> {
+    asChild?: boolean;
+    value: string;
+    disabled?: boolean;
+}
+interface TabsContentProps extends React.ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+    value: string;
+    forceMount?: boolean;
+}
+
+declare const Root$z: React.ForwardRefExoticComponent<TabsRootProps & React.RefAttributes<HTMLDivElement>>;
+declare const List$4: React.ForwardRefExoticComponent<TabsListProps & React.RefAttributes<HTMLDivElement>>;
+declare const Trigger$f: React.ForwardRefExoticComponent<TabsTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const Content$g: React.ForwardRefExoticComponent<TabsContentProps & React.RefAttributes<HTMLDivElement>>;
+
+type index$C_TabsContentProps = TabsContentProps;
+type index$C_TabsListProps = TabsListProps;
+type index$C_TabsRootProps = TabsRootProps;
+type index$C_TabsTriggerProps = TabsTriggerProps;
+declare namespace index$C {
+  export { Content$g as Content, List$4 as List, Root$z as Root, type index$C_TabsContentProps as TabsContentProps, type index$C_TabsListProps as TabsListProps, type index$C_TabsRootProps as TabsRootProps, type index$C_TabsTriggerProps as TabsTriggerProps, Trigger$f as Trigger };
+}
+
+interface AlertDialogRootProps extends Omit<DialogRootProps, 'modal'> {
+}
+interface AlertDialogTriggerProps extends DialogTriggerProps {
+}
+interface AlertDialogPortalProps extends DialogPortalProps {
+}
+interface AlertDialogOverlayProps extends DialogOverlayProps {
+}
+interface AlertDialogContentProps extends Omit<DialogContentProps, 'onPointerDownOutside' | 'onInteractOutside'> {
+}
+interface AlertDialogTitleProps extends DialogTitleProps {
+}
+interface AlertDialogDescriptionProps extends DialogDescriptionProps {
+}
+interface AlertDialogActionProps extends React.ComponentPropsWithoutRef<'button'> {
+    asChild?: boolean;
+}
+interface AlertDialogCancelProps extends DialogCloseProps {
+}
+
+declare const Root$y: React.FC<AlertDialogRootProps>;
+declare const Trigger$e: React.ForwardRefExoticComponent<AlertDialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const Portal$f: React.FC<AlertDialogPortalProps>;
+declare const Overlay: React.ForwardRefExoticComponent<AlertDialogOverlayProps & React.RefAttributes<HTMLDivElement>>;
+declare const Content$f: React.ForwardRefExoticComponent<AlertDialogContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const Title$2: React.ForwardRefExoticComponent<AlertDialogTitleProps & React.RefAttributes<HTMLHeadingElement>>;
+declare const Description$2: React.ForwardRefExoticComponent<AlertDialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>>;
+declare const Action$1: React.ForwardRefExoticComponent<AlertDialogActionProps & React.RefAttributes<HTMLButtonElement>>;
+declare const Cancel: React.ForwardRefExoticComponent<AlertDialogCancelProps & React.RefAttributes<HTMLButtonElement>>;
+
+type index$B_AlertDialogActionProps = AlertDialogActionProps;
+type index$B_AlertDialogCancelProps = AlertDialogCancelProps;
+type index$B_AlertDialogContentProps = AlertDialogContentProps;
+type index$B_AlertDialogDescriptionProps = AlertDialogDescriptionProps;
+type index$B_AlertDialogOverlayProps = AlertDialogOverlayProps;
+type index$B_AlertDialogPortalProps = AlertDialogPortalProps;
+type index$B_AlertDialogRootProps = AlertDialogRootProps;
+type index$B_AlertDialogTitleProps = AlertDialogTitleProps;
+type index$B_AlertDialogTriggerProps = AlertDialogTriggerProps;
+declare const index$B_Cancel: typeof Cancel;
+declare const index$B_Overlay: typeof Overlay;
+declare namespace index$B {
+  export { Action$1 as Action, type index$B_AlertDialogActionProps as AlertDialogActionProps, type index$B_AlertDialogCancelProps as AlertDialogCancelProps, type index$B_AlertDialogContentProps as AlertDialogContentProps, type index$B_AlertDialogDescriptionProps as AlertDialogDescriptionProps, type index$B_AlertDialogOverlayProps as AlertDialogOverlayProps, type index$B_AlertDialogPortalProps as AlertDialogPortalProps, type index$B_AlertDialogRootProps as AlertDialogRootProps, type index$B_AlertDialogTitleProps as AlertDialogTitleProps, type index$B_AlertDialogTriggerProps as AlertDialogTriggerProps, index$B_Cancel as Cancel, Content$f as Content, Description$2 as Description, index$B_Overlay as Overlay, Portal$f as Portal, Root$y as Root, Title$2 as Title, Trigger$e as Trigger };
+}
+
+interface PopoverRootProps {
+    children?: React.ReactNode;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    modal?: boolean;
+}
+interface PopoverTriggerProps extends React.ComponentPropsWithoutRef<'button'> {
+    asChild?: boolean;
+}
+interface PopoverAnchorProps extends React.ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+}
+interface PopoverPortalProps {
+    children?: React.ReactNode;
+    container?: Element | DocumentFragment | null;
+    forceMount?: boolean;
+}
+interface PopoverContentProps extends React.ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+    forceMount?: boolean;
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    sideOffset?: number;
+    align?: 'start' | 'center' | 'end';
+    alignOffset?: number;
+    arrowPadding?: number;
+    avoidCollisions?: boolean;
+    collisionBoundary?: Element | Element[] | null;
+    collisionPadding?: number;
+    strategy?: 'fixed' | 'absolute';
+    sticky?: 'partial' | 'always';
+    hideWhenDetached?: boolean;
+    updatePositionStrategy?: 'always' | 'optimized';
+    onOpenAutoFocus?: (event: Event) => void;
+    onCloseAutoFocus?: (event: Event) => void;
+    onEscapeKeyDown?: (event: KeyboardEvent) => void;
+    onPointerDownOutside?: (event: PointerDownOutsideEvent) => void;
+    onFocusOutside?: (event: FocusOutsideEvent) => void;
+    onInteractOutside?: (event: PointerDownOutsideEvent | FocusOutsideEvent) => void;
+}
+interface PopoverCloseProps extends React.ComponentPropsWithoutRef<'button'> {
+    asChild?: boolean;
+}
+interface PopoverArrowProps extends React.ComponentPropsWithoutRef<'svg'> {
+    width?: number;
+    height?: number;
+}
+
+declare const Root$x: React.FC<PopoverRootProps>;
+declare const Anchor$4: React.ForwardRefExoticComponent<PopoverAnchorProps & React.RefAttributes<HTMLDivElement>>;
+declare const Trigger$d: React.ForwardRefExoticComponent<PopoverTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const Portal$e: React.FC<PopoverPortalProps>;
+declare const Content$e: React.ForwardRefExoticComponent<PopoverContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const Close$1: React.ForwardRefExoticComponent<PopoverCloseProps & React.RefAttributes<HTMLButtonElement>>;
+declare const Arrow$2: React.ForwardRefExoticComponent<PopoverArrowProps & React.RefAttributes<SVGSVGElement>>;
+
+type index$A_PopoverAnchorProps = PopoverAnchorProps;
+type index$A_PopoverArrowProps = PopoverArrowProps;
+type index$A_PopoverCloseProps = PopoverCloseProps;
+type index$A_PopoverContentProps = PopoverContentProps;
+type index$A_PopoverPortalProps = PopoverPortalProps;
+type index$A_PopoverRootProps = PopoverRootProps;
+type index$A_PopoverTriggerProps = PopoverTriggerProps;
+declare namespace index$A {
+  export { Anchor$4 as Anchor, Arrow$2 as Arrow, Close$1 as Close, Content$e as Content, type index$A_PopoverAnchorProps as PopoverAnchorProps, type index$A_PopoverArrowProps as PopoverArrowProps, type index$A_PopoverCloseProps as PopoverCloseProps, type index$A_PopoverContentProps as PopoverContentProps, type index$A_PopoverPortalProps as PopoverPortalProps, type index$A_PopoverRootProps as PopoverRootProps, type index$A_PopoverTriggerProps as PopoverTriggerProps, Portal$e as Portal, Root$x as Root, Trigger$d as Trigger };
+}
+
+interface TooltipProviderProps {
+    children?: React.ReactNode;
+    /** Delay before the tooltip opens (ms). */
+    delayDuration?: number;
+    /** How long after closing before another tooltip will skip the delay (ms). */
+    skipDelayDuration?: number;
+    /** When true, all tooltips inside disable the hoverable content behavior. */
+    disableHoverableContent?: boolean;
+}
+interface TooltipRootProps {
+    children?: React.ReactNode;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    delayDuration?: number;
+    disableHoverableContent?: boolean;
+}
+interface TooltipTriggerProps extends React.ComponentPropsWithoutRef<'button'> {
+    asChild?: boolean;
+}
+interface TooltipPortalProps {
+    children?: React.ReactNode;
+    container?: Element | DocumentFragment | null;
+    forceMount?: boolean;
+}
+interface TooltipContentProps extends React.ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+    forceMount?: boolean;
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    sideOffset?: number;
+    align?: 'start' | 'center' | 'end';
+    alignOffset?: number;
+    arrowPadding?: number;
+    avoidCollisions?: boolean;
+    collisionPadding?: number;
+    /** Time (ms) to allow the cursor to leave trigger before closing. */
+    onEscapeKeyDown?: (event: KeyboardEvent) => void;
+    onPointerDownOutside?: (event: PointerEvent) => void;
+}
+interface TooltipArrowProps extends React.ComponentPropsWithoutRef<'svg'> {
+    width?: number;
+    height?: number;
+}
+
+declare const Provider$1: React.FC<TooltipProviderProps>;
+declare const Root$w: React.FC<TooltipRootProps>;
+declare const Trigger$c: React.ForwardRefExoticComponent<TooltipTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const Portal$d: React.FC<TooltipPortalProps>;
+declare const Content$d: React.ForwardRefExoticComponent<TooltipContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const Arrow$1: React.ForwardRefExoticComponent<TooltipArrowProps & React.RefAttributes<SVGSVGElement>>;
+
+type index$z_TooltipArrowProps = TooltipArrowProps;
+type index$z_TooltipContentProps = TooltipContentProps;
+type index$z_TooltipPortalProps = TooltipPortalProps;
+type index$z_TooltipProviderProps = TooltipProviderProps;
+type index$z_TooltipRootProps = TooltipRootProps;
+type index$z_TooltipTriggerProps = TooltipTriggerProps;
+declare namespace index$z {
+  export { Arrow$1 as Arrow, Content$d as Content, Portal$d as Portal, Provider$1 as Provider, Root$w as Root, type index$z_TooltipArrowProps as TooltipArrowProps, type index$z_TooltipContentProps as TooltipContentProps, type index$z_TooltipPortalProps as TooltipPortalProps, type index$z_TooltipProviderProps as TooltipProviderProps, type index$z_TooltipRootProps as TooltipRootProps, type index$z_TooltipTriggerProps as TooltipTriggerProps, Trigger$c as Trigger };
+}
+
+interface HoverCardRootProps {
+    children?: React.ReactNode;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    openDelay?: number;
+    closeDelay?: number;
+}
+interface HoverCardTriggerProps extends React.ComponentPropsWithoutRef<'a'> {
+    asChild?: boolean;
+}
+interface HoverCardPortalProps {
+    children?: React.ReactNode;
+    container?: Element | DocumentFragment | null;
+    forceMount?: boolean;
+}
+interface HoverCardContentProps extends React.ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+    forceMount?: boolean;
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    sideOffset?: number;
+    align?: 'start' | 'center' | 'end';
+    alignOffset?: number;
+    arrowPadding?: number;
+    avoidCollisions?: boolean;
+    collisionPadding?: number;
+}
+interface HoverCardArrowProps extends React.ComponentPropsWithoutRef<'svg'> {
+    width?: number;
+    height?: number;
+}
+
+declare const Root$v: React.FC<HoverCardRootProps>;
+declare const Trigger$b: React.ForwardRefExoticComponent<HoverCardTriggerProps & React.RefAttributes<HTMLAnchorElement>>;
+declare const Portal$c: React.FC<HoverCardPortalProps>;
+declare const Content$c: React.ForwardRefExoticComponent<HoverCardContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const Arrow: React.ForwardRefExoticComponent<HoverCardArrowProps & React.RefAttributes<SVGSVGElement>>;
+
+declare const index$y_Arrow: typeof Arrow;
+type index$y_HoverCardArrowProps = HoverCardArrowProps;
+type index$y_HoverCardContentProps = HoverCardContentProps;
+type index$y_HoverCardPortalProps = HoverCardPortalProps;
+type index$y_HoverCardRootProps = HoverCardRootProps;
+type index$y_HoverCardTriggerProps = HoverCardTriggerProps;
+declare namespace index$y {
+  export { index$y_Arrow as Arrow, Content$c as Content, type index$y_HoverCardArrowProps as HoverCardArrowProps, type index$y_HoverCardContentProps as HoverCardContentProps, type index$y_HoverCardPortalProps as HoverCardPortalProps, type index$y_HoverCardRootProps as HoverCardRootProps, type index$y_HoverCardTriggerProps as HoverCardTriggerProps, Portal$c as Portal, Root$v as Root, Trigger$b as Trigger };
+}
+
+type SwipeDirection = 'up' | 'down' | 'left' | 'right';
+interface ToastProviderProps {
+    children?: React.ReactNode;
+    /** Aria label for the toast region. */
+    label?: string;
+    /** Time in ms to auto-dismiss toasts. Set to Infinity to disable. */
+    duration?: number;
+    /** Direction users can swipe to dismiss. */
+    swipeDirection?: SwipeDirection;
+    /** Distance in px to consider a swipe a dismissal. */
+    swipeThreshold?: number;
+}
+interface ToastViewportProps extends React.ComponentPropsWithoutRef<'ol'> {
+    asChild?: boolean;
+    /** Keys to focus next/previous toast (default F8). */
+    hotkey?: string[];
+    label?: string;
+}
+interface ToastRootProps extends React.ComponentPropsWithoutRef<'li'> {
+    asChild?: boolean;
+    type?: 'foreground' | 'background';
+    duration?: number;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    forceMount?: boolean;
+    onEscapeKeyDown?: (event: KeyboardEvent) => void;
+    onPause?: () => void;
+    onResume?: () => void;
+    onSwipeStart?: (event: React.PointerEvent) => void;
+    onSwipeMove?: (event: React.PointerEvent) => void;
+    onSwipeEnd?: (event: React.PointerEvent) => void;
+    onSwipeCancel?: (event: React.PointerEvent) => void;
+}
+interface ToastTitleProps extends React.ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+}
+interface ToastDescriptionProps extends React.ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+}
+interface ToastActionProps extends React.ComponentPropsWithoutRef<'button'> {
+    asChild?: boolean;
+    altText: string;
+}
+interface ToastCloseProps extends React.ComponentPropsWithoutRef<'button'> {
+    asChild?: boolean;
+}
+
+declare const Provider: React.FC<ToastProviderProps>;
+declare const Viewport$5: React.ForwardRefExoticComponent<ToastViewportProps & React.RefAttributes<HTMLOListElement>>;
+declare const Root$u: React.ForwardRefExoticComponent<ToastRootProps & React.RefAttributes<HTMLLIElement>>;
+declare const Title$1: React.ForwardRefExoticComponent<ToastTitleProps & React.RefAttributes<HTMLDivElement>>;
+declare const Description$1: React.ForwardRefExoticComponent<ToastDescriptionProps & React.RefAttributes<HTMLDivElement>>;
+declare const Action: React.ForwardRefExoticComponent<ToastActionProps & React.RefAttributes<HTMLButtonElement>>;
+declare const Close: React.ForwardRefExoticComponent<ToastCloseProps & React.RefAttributes<HTMLButtonElement>>;
+declare const Portal$b: React.FC<{
+    children?: React.ReactNode;
+    container?: Element | DocumentFragment | null;
+}>;
+
+declare const index$x_Action: typeof Action;
+declare const index$x_Close: typeof Close;
+declare const index$x_Provider: typeof Provider;
+type index$x_SwipeDirection = SwipeDirection;
+type index$x_ToastActionProps = ToastActionProps;
+type index$x_ToastCloseProps = ToastCloseProps;
+type index$x_ToastDescriptionProps = ToastDescriptionProps;
+type index$x_ToastProviderProps = ToastProviderProps;
+type index$x_ToastRootProps = ToastRootProps;
+type index$x_ToastTitleProps = ToastTitleProps;
+type index$x_ToastViewportProps = ToastViewportProps;
+declare namespace index$x {
+  export { index$x_Action as Action, index$x_Close as Close, Description$1 as Description, Portal$b as Portal, index$x_Provider as Provider, Root$u as Root, type index$x_SwipeDirection as SwipeDirection, Title$1 as Title, type index$x_ToastActionProps as ToastActionProps, type index$x_ToastCloseProps as ToastCloseProps, type index$x_ToastDescriptionProps as ToastDescriptionProps, type index$x_ToastProviderProps as ToastProviderProps, type index$x_ToastRootProps as ToastRootProps, type index$x_ToastTitleProps as ToastTitleProps, type index$x_ToastViewportProps as ToastViewportProps, Viewport$5 as Viewport };
+}
+
+interface MenuRootProps {
+    children?: React.ReactNode;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    modal?: boolean;
+    dir?: 'ltr' | 'rtl';
+}
+interface MenuAnchorProps extends React.ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+    virtualRef?: React.RefObject<{
+        getBoundingClientRect: () => DOMRect;
+    }>;
+}
+interface MenuPortalProps {
+    children?: React.ReactNode;
+    container?: Element | DocumentFragment | null;
+    forceMount?: boolean;
+}
+interface MenuContentProps extends React.ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+    forceMount?: boolean;
+    loop?: boolean;
+    onCloseAutoFocus?: (event: Event) => void;
+    onEscapeKeyDown?: (event: KeyboardEvent) => void;
+    onPointerDownOutside?: (event: PointerDownOutsideEvent) => void;
+    onFocusOutside?: (event: FocusOutsideEvent) => void;
+    onInteractOutside?: (event: PointerDownOutsideEvent | FocusOutsideEvent) => void;
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    sideOffset?: number;
+    align?: 'start' | 'center' | 'end';
+    alignOffset?: number;
+    avoidCollisions?: boolean;
+    collisionBoundary?: Element | Element[] | null;
+    collisionPadding?: number;
+    strategy?: 'fixed' | 'absolute';
+    sticky?: 'partial' | 'always';
+    hideWhenDetached?: boolean;
+    updatePositionStrategy?: 'always' | 'optimized';
+}
+interface MenuItemProps extends Omit<React.ComponentPropsWithoutRef<'div'>, 'onSelect'> {
+    asChild?: boolean;
+    disabled?: boolean;
+    onSelect?: (event: Event) => void;
+    textValue?: string;
+}
+interface MenuGroupProps extends React.ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+}
+interface MenuLabelProps extends React.ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+}
+interface MenuCheckboxItemProps extends Omit<MenuItemProps, 'onSelect'> {
+    checked?: boolean | 'indeterminate';
+    onCheckedChange?: (checked: boolean) => void;
+    onSelect?: (event: Event) => void;
+}
+interface MenuRadioGroupProps extends MenuGroupProps {
+    value?: string;
+    onValueChange?: (value: string) => void;
+}
+interface MenuRadioItemProps extends Omit<MenuItemProps, 'onSelect'> {
+    value: string;
+    onSelect?: (event: Event) => void;
+}
+interface MenuItemIndicatorProps extends React.ComponentPropsWithoutRef<'span'> {
+    asChild?: boolean;
+    forceMount?: boolean;
+}
+interface MenuSeparatorProps extends React.ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+}
+
+declare const Root$t: React.FC<MenuRootProps>;
+declare const Anchor$3: React.ForwardRefExoticComponent<MenuAnchorProps & React.RefAttributes<HTMLDivElement>>;
+declare const Portal$a: React.FC<MenuPortalProps>;
+declare const Content$b: React.ForwardRefExoticComponent<MenuContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const Item$b: React.ForwardRefExoticComponent<MenuItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const Group$9: React.ForwardRefExoticComponent<MenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const Label$6: React.ForwardRefExoticComponent<MenuLabelProps & React.RefAttributes<HTMLDivElement>>;
+declare const Separator$9: React.ForwardRefExoticComponent<MenuSeparatorProps & React.RefAttributes<HTMLDivElement>>;
+declare const CheckboxItem$3: React.ForwardRefExoticComponent<MenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const RadioGroup$3: React.ForwardRefExoticComponent<MenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const RadioItem$3: React.ForwardRefExoticComponent<MenuRadioItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const ItemIndicator$5: React.ForwardRefExoticComponent<MenuItemIndicatorProps & React.RefAttributes<HTMLSpanElement>>;
+declare const Sub$3: React.FC<{
+    children?: React.ReactNode;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}>;
+declare const SubTrigger$3: React.ForwardRefExoticComponent<MenuItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const SubContent$3: React.ForwardRefExoticComponent<Omit<MenuContentProps, "side" | "align"> & React.RefAttributes<HTMLDivElement>>;
+
+type index$w_MenuAnchorProps = MenuAnchorProps;
+type index$w_MenuCheckboxItemProps = MenuCheckboxItemProps;
+type index$w_MenuContentProps = MenuContentProps;
+type index$w_MenuGroupProps = MenuGroupProps;
+type index$w_MenuItemIndicatorProps = MenuItemIndicatorProps;
+type index$w_MenuItemProps = MenuItemProps;
+type index$w_MenuLabelProps = MenuLabelProps;
+type index$w_MenuPortalProps = MenuPortalProps;
+type index$w_MenuRadioGroupProps = MenuRadioGroupProps;
+type index$w_MenuRadioItemProps = MenuRadioItemProps;
+type index$w_MenuRootProps = MenuRootProps;
+type index$w_MenuSeparatorProps = MenuSeparatorProps;
+declare namespace index$w {
+  export { Anchor$3 as Anchor, CheckboxItem$3 as CheckboxItem, Content$b as Content, Group$9 as Group, Item$b as Item, ItemIndicator$5 as ItemIndicator, Label$6 as Label, type index$w_MenuAnchorProps as MenuAnchorProps, type index$w_MenuCheckboxItemProps as MenuCheckboxItemProps, type index$w_MenuContentProps as MenuContentProps, type index$w_MenuGroupProps as MenuGroupProps, type index$w_MenuItemIndicatorProps as MenuItemIndicatorProps, type index$w_MenuItemProps as MenuItemProps, type index$w_MenuLabelProps as MenuLabelProps, type index$w_MenuPortalProps as MenuPortalProps, type index$w_MenuRadioGroupProps as MenuRadioGroupProps, type index$w_MenuRadioItemProps as MenuRadioItemProps, type index$w_MenuRootProps as MenuRootProps, type index$w_MenuSeparatorProps as MenuSeparatorProps, Portal$a as Portal, RadioGroup$3 as RadioGroup, RadioItem$3 as RadioItem, Root$t as Root, Separator$9 as Separator, Sub$3 as Sub, SubContent$3 as SubContent, SubTrigger$3 as SubTrigger };
+}
+
+interface DropdownMenuRootProps {
+    children?: React.ReactNode;
+    dir?: 'ltr' | 'rtl';
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    modal?: boolean;
+}
+declare const Root$s: React.FC<DropdownMenuRootProps>;
+interface DropdownMenuTriggerProps extends React.ComponentPropsWithoutRef<'button'> {
+    asChild?: boolean;
+}
+declare const Trigger$a: React.ForwardRefExoticComponent<DropdownMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const Portal$9: React.FC<MenuPortalProps>;
+declare const Content$a: React.ForwardRefExoticComponent<Omit<MenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const Item$a: React.ForwardRefExoticComponent<MenuItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const Group$8: React.ForwardRefExoticComponent<MenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const Label$5: React.ForwardRefExoticComponent<MenuLabelProps & React.RefAttributes<HTMLDivElement>>;
+declare const CheckboxItem$2: React.ForwardRefExoticComponent<MenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const RadioGroup$2: React.ForwardRefExoticComponent<MenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const RadioItem$2: React.ForwardRefExoticComponent<MenuRadioItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const ItemIndicator$4: React.ForwardRefExoticComponent<MenuItemIndicatorProps & React.RefAttributes<HTMLSpanElement>>;
+declare const Separator$8: React.ForwardRefExoticComponent<MenuSeparatorProps & React.RefAttributes<HTMLDivElement>>;
+declare const Sub$2: React.FC<{
+    children?: React.ReactNode;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}>;
+declare const SubTrigger$2: React.ForwardRefExoticComponent<MenuItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const SubContent$2: React.ForwardRefExoticComponent<Omit<MenuContentProps, "side" | "align"> & React.RefAttributes<HTMLDivElement>>;
+
+type index$v_DropdownMenuRootProps = DropdownMenuRootProps;
+type index$v_DropdownMenuTriggerProps = DropdownMenuTriggerProps;
+declare namespace index$v {
+  export { CheckboxItem$2 as CheckboxItem, Content$a as Content, type index$v_DropdownMenuRootProps as DropdownMenuRootProps, type index$v_DropdownMenuTriggerProps as DropdownMenuTriggerProps, Group$8 as Group, Item$a as Item, ItemIndicator$4 as ItemIndicator, Label$5 as Label, Portal$9 as Portal, RadioGroup$2 as RadioGroup, RadioItem$2 as RadioItem, Root$s as Root, Separator$8 as Separator, Sub$2 as Sub, SubContent$2 as SubContent, SubTrigger$2 as SubTrigger, Trigger$a as Trigger };
+}
+
+interface ContextMenuRootProps {
+    children?: React.ReactNode;
+    dir?: 'ltr' | 'rtl';
+    onOpenChange?: (open: boolean) => void;
+    modal?: boolean;
+}
+declare const Root$r: React.FC<ContextMenuRootProps>;
+interface ContextMenuTriggerProps extends React.ComponentPropsWithoutRef<'span'> {
+    asChild?: boolean;
+    disabled?: boolean;
+}
+declare const Trigger$9: React.ForwardRefExoticComponent<ContextMenuTriggerProps & React.RefAttributes<HTMLSpanElement>>;
+declare const Portal$8: React.FC<MenuPortalProps>;
+declare const Content$9: React.ForwardRefExoticComponent<Omit<Omit<MenuContentProps & React.RefAttributes<HTMLDivElement>, "ref">, "side" | "sideOffset" | "align"> & React.RefAttributes<HTMLDivElement>>;
+declare const Item$9: React.ForwardRefExoticComponent<MenuItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const Group$7: React.ForwardRefExoticComponent<MenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const Label$4: React.ForwardRefExoticComponent<MenuLabelProps & React.RefAttributes<HTMLDivElement>>;
+declare const CheckboxItem$1: React.ForwardRefExoticComponent<MenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const RadioGroup$1: React.ForwardRefExoticComponent<MenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const RadioItem$1: React.ForwardRefExoticComponent<MenuRadioItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const ItemIndicator$3: React.ForwardRefExoticComponent<MenuItemIndicatorProps & React.RefAttributes<HTMLSpanElement>>;
+declare const Separator$7: React.ForwardRefExoticComponent<MenuSeparatorProps & React.RefAttributes<HTMLDivElement>>;
+declare const Sub$1: React.FC<{
+    children?: React.ReactNode;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}>;
+declare const SubTrigger$1: React.ForwardRefExoticComponent<MenuItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const SubContent$1: React.ForwardRefExoticComponent<Omit<MenuContentProps, "side" | "align"> & React.RefAttributes<HTMLDivElement>>;
+
+type index$u_ContextMenuRootProps = ContextMenuRootProps;
+type index$u_ContextMenuTriggerProps = ContextMenuTriggerProps;
+declare namespace index$u {
+  export { CheckboxItem$1 as CheckboxItem, Content$9 as Content, type index$u_ContextMenuRootProps as ContextMenuRootProps, type index$u_ContextMenuTriggerProps as ContextMenuTriggerProps, Group$7 as Group, Item$9 as Item, ItemIndicator$3 as ItemIndicator, Label$4 as Label, Portal$8 as Portal, RadioGroup$1 as RadioGroup, RadioItem$1 as RadioItem, Root$r as Root, Separator$7 as Separator, Sub$1 as Sub, SubContent$1 as SubContent, SubTrigger$1 as SubTrigger, Trigger$9 as Trigger };
+}
+
+interface MenubarRootProps extends React.ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    dir?: 'ltr' | 'rtl';
+    loop?: boolean;
+}
+declare const Root$q: React.ForwardRefExoticComponent<MenubarRootProps & React.RefAttributes<HTMLDivElement>>;
+declare const Menu: React.FC<{
+    children?: React.ReactNode;
+    value?: string;
+}>;
+interface MenubarTriggerProps extends React.ComponentPropsWithoutRef<'button'> {
+    asChild?: boolean;
+    disabled?: boolean;
+}
+declare const Trigger$8: React.ForwardRefExoticComponent<MenubarTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const Portal$7: React.FC<MenuPortalProps>;
+declare const Content$8: React.ForwardRefExoticComponent<Omit<MenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const Item$8: React.ForwardRefExoticComponent<MenuItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const Group$6: React.ForwardRefExoticComponent<MenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const Label$3: React.ForwardRefExoticComponent<MenuLabelProps & React.RefAttributes<HTMLDivElement>>;
+declare const CheckboxItem: React.ForwardRefExoticComponent<MenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const RadioGroup: React.ForwardRefExoticComponent<MenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const RadioItem: React.ForwardRefExoticComponent<MenuRadioItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const ItemIndicator$2: React.ForwardRefExoticComponent<MenuItemIndicatorProps & React.RefAttributes<HTMLSpanElement>>;
+declare const Separator$6: React.ForwardRefExoticComponent<MenuSeparatorProps & React.RefAttributes<HTMLDivElement>>;
+declare const Sub: React.FC<{
+    children?: React.ReactNode;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}>;
+declare const SubTrigger: React.ForwardRefExoticComponent<MenuItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const SubContent: React.ForwardRefExoticComponent<Omit<MenuContentProps, "side" | "align"> & React.RefAttributes<HTMLDivElement>>;
+
+declare const index$t_CheckboxItem: typeof CheckboxItem;
+declare const index$t_Menu: typeof Menu;
+type index$t_MenubarRootProps = MenubarRootProps;
+type index$t_MenubarTriggerProps = MenubarTriggerProps;
+declare const index$t_RadioGroup: typeof RadioGroup;
+declare const index$t_RadioItem: typeof RadioItem;
+declare const index$t_Sub: typeof Sub;
+declare const index$t_SubContent: typeof SubContent;
+declare const index$t_SubTrigger: typeof SubTrigger;
+declare namespace index$t {
+  export { index$t_CheckboxItem as CheckboxItem, Content$8 as Content, Group$6 as Group, Item$8 as Item, ItemIndicator$2 as ItemIndicator, Label$3 as Label, index$t_Menu as Menu, type index$t_MenubarRootProps as MenubarRootProps, type index$t_MenubarTriggerProps as MenubarTriggerProps, Portal$7 as Portal, index$t_RadioGroup as RadioGroup, index$t_RadioItem as RadioItem, Root$q as Root, Separator$6 as Separator, index$t_Sub as Sub, index$t_SubContent as SubContent, index$t_SubTrigger as SubTrigger, Trigger$8 as Trigger };
+}
+
+interface NavigationMenuRootProps extends React.ComponentPropsWithoutRef<'nav'> {
+    asChild?: boolean;
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    delayDuration?: number;
+    skipDelayDuration?: number;
+    dir?: 'ltr' | 'rtl';
+    orientation?: 'horizontal' | 'vertical';
+}
+declare const Root$p: React.ForwardRefExoticComponent<NavigationMenuRootProps & React.RefAttributes<HTMLElement>>;
+declare const List$3: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & React.RefAttributes<HTMLUListElement>>;
+interface NavigationMenuItemProps extends React.ComponentPropsWithoutRef<'li'> {
+    asChild?: boolean;
+    value?: string;
+}
+declare const Item$7: React.ForwardRefExoticComponent<NavigationMenuItemProps & React.RefAttributes<HTMLLIElement>>;
+declare const Trigger$7: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+    asChild?: boolean;
+} & React.RefAttributes<HTMLButtonElement>>;
+interface NavigationMenuLinkProps extends React.ComponentPropsWithoutRef<'a'> {
+    asChild?: boolean;
+    active?: boolean;
+}
+declare const Link$2: React.ForwardRefExoticComponent<NavigationMenuLinkProps & React.RefAttributes<HTMLAnchorElement>>;
+declare const Content$7: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    asChild?: boolean;
+    forceMount?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const Indicator: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    forceMount?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const Viewport$4: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    forceMount?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+
+declare const index$s_Indicator: typeof Indicator;
+type index$s_NavigationMenuItemProps = NavigationMenuItemProps;
+type index$s_NavigationMenuLinkProps = NavigationMenuLinkProps;
+type index$s_NavigationMenuRootProps = NavigationMenuRootProps;
+declare namespace index$s {
+  export { Content$7 as Content, index$s_Indicator as Indicator, Item$7 as Item, Link$2 as Link, List$3 as List, type index$s_NavigationMenuItemProps as NavigationMenuItemProps, type index$s_NavigationMenuLinkProps as NavigationMenuLinkProps, type index$s_NavigationMenuRootProps as NavigationMenuRootProps, Root$p as Root, Trigger$7 as Trigger, Viewport$4 as Viewport };
+}
+
+interface BreadcrumbProps extends React.HTMLAttributes<HTMLElement> {
+    label?: string;
+}
+declare const Breadcrumb: React.ForwardRefExoticComponent<BreadcrumbProps & React.RefAttributes<HTMLElement>>;
+declare const BreadcrumbItem: React.ForwardRefExoticComponent<React.LiHTMLAttributes<HTMLLIElement> & React.RefAttributes<HTMLLIElement>>;
+declare const BreadcrumbLink: React.ForwardRefExoticComponent<React.AnchorHTMLAttributes<HTMLAnchorElement> & React.RefAttributes<HTMLAnchorElement>>;
+
+declare const index$r_Breadcrumb: typeof Breadcrumb;
+declare const index$r_BreadcrumbItem: typeof BreadcrumbItem;
+declare const index$r_BreadcrumbLink: typeof BreadcrumbLink;
+type index$r_BreadcrumbProps = BreadcrumbProps;
+declare namespace index$r {
+  export { index$r_Breadcrumb as Breadcrumb, index$r_BreadcrumbItem as BreadcrumbItem, index$r_BreadcrumbLink as BreadcrumbLink, type index$r_BreadcrumbProps as BreadcrumbProps };
+}
+
+interface PaginationProps extends Omit<React.ComponentPropsWithoutRef<'nav'>, 'onChange'> {
+    current?: number;
+    total?: number;
+    onChange?: (page: number) => void;
+}
+
+declare const Root$o: React.ForwardRefExoticComponent<PaginationProps & React.RefAttributes<HTMLDivElement>>;
+
+declare namespace index$q {
+  export { Root$o as Root };
+}
+
+interface StepperProps extends Omit<React.ComponentPropsWithoutRef<'div'>, 'onChange'> {
+    value?: number;
+    defaultValue?: number;
+    onChange?: (value: number) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+}
+interface StepperButtonProps extends React.ComponentPropsWithoutRef<'button'> {
+}
+
+declare const Root$n: React.ForwardRefExoticComponent<StepperProps & React.RefAttributes<HTMLDivElement>>;
+
+declare namespace index$p {
+  export { Root$n as Root };
+}
+
+interface SelectFilterOption {
+    value: string;
+    textValue: string;
+}
+interface SelectOption {
+    value: string;
+    label: React.ReactNode;
+    textValue?: string;
+    disabled?: boolean;
+}
+interface SelectRootProps {
+    children?: React.ReactNode;
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    dir?: 'ltr' | 'rtl';
+    name?: string;
+    autoComplete?: string;
+    disabled?: boolean;
+    required?: boolean;
+    searchable?: boolean;
+    searchValue?: string;
+    defaultSearchValue?: string;
+    onSearchValueChange?: (value: string) => void;
+    filterOption?: (option: SelectFilterOption, searchValue: string) => boolean;
+    onCreateOption?: (value: string) => void;
+    createOptionLabel?: React.ReactNode | ((value: string) => React.ReactNode);
+    resetSearchOnClose?: boolean;
+}
+declare const Root$m: React.FC<SelectRootProps>;
+interface SelectTriggerProps extends React.ComponentPropsWithoutRef<'button'> {
+    asChild?: boolean;
+}
+declare const Trigger$6: React.ForwardRefExoticComponent<SelectTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+interface SelectValueProps extends React.ComponentPropsWithoutRef<'span'> {
+    asChild?: boolean;
+    placeholder?: React.ReactNode;
+}
+declare const Value$5: React.ForwardRefExoticComponent<SelectValueProps & React.RefAttributes<HTMLSpanElement>>;
+declare const Icon$2: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+    asChild?: boolean;
+} & React.RefAttributes<HTMLSpanElement>>;
+interface SelectSearchInputProps extends React.ComponentPropsWithoutRef<'input'> {
+    asChild?: boolean;
+}
+declare const SearchInput$1: React.ForwardRefExoticComponent<SelectSearchInputProps & React.RefAttributes<HTMLInputElement>>;
+interface SelectPortalProps {
+    children?: React.ReactNode;
+    container?: Element | DocumentFragment | null;
+    forceMount?: boolean;
+}
+declare const Portal$6: React.FC<SelectPortalProps>;
+interface SelectContentProps extends React.ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+    forceMount?: boolean;
+    position?: 'item-aligned' | 'popper';
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    sideOffset?: number;
+    align?: 'start' | 'center' | 'end';
+    alignOffset?: number;
+    avoidCollisions?: boolean;
+    collisionBoundary?: Element | Element[] | null;
+    collisionPadding?: number;
+    strategy?: 'fixed' | 'absolute';
+    sticky?: 'partial' | 'always';
+    hideWhenDetached?: boolean;
+    updatePositionStrategy?: 'always' | 'optimized';
+    onCloseAutoFocus?: (event: Event) => void;
+    onEscapeKeyDown?: (event: KeyboardEvent) => void;
+    onPointerDownOutside?: (event: Event) => void;
+}
+declare const Content$6: React.ForwardRefExoticComponent<SelectContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const Viewport$3: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    asChild?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+interface SelectItemProps extends React.ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+    value: string;
+    disabled?: boolean;
+    textValue?: string;
+}
+declare const Item$6: React.ForwardRefExoticComponent<SelectItemProps & React.RefAttributes<HTMLDivElement>>;
+interface SelectCreateItemProps extends Omit<React.ComponentPropsWithoutRef<'div'>, 'children'> {
+    asChild?: boolean;
+    value?: string;
+    children?: React.ReactNode | ((value: string) => React.ReactNode);
+}
+declare const CreateItem$1: React.ForwardRefExoticComponent<SelectCreateItemProps & React.RefAttributes<HTMLDivElement>>;
+interface SelectItemTextProps extends React.ComponentPropsWithoutRef<'span'> {
+    asChild?: boolean;
+}
+declare const ItemText$1: React.ForwardRefExoticComponent<SelectItemTextProps & React.RefAttributes<HTMLSpanElement>>;
+declare const ItemIndicator$1: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+    asChild?: boolean;
+} & React.RefAttributes<HTMLSpanElement>>;
+interface SelectOptionsProps extends React.ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+    options: SelectOption[];
+    itemHeight?: number;
+    overscan?: number;
+    visibleItemCount?: number;
+    emptyMessage?: React.ReactNode;
+    itemClassName?: string;
+    itemTextClassName?: string;
+    itemIndicatorClassName?: string;
+    renderOption?: (option: SelectOption) => React.ReactNode;
+    renderItemIndicator?: (option: SelectOption) => React.ReactNode;
+}
+declare const Options$1: React.ForwardRefExoticComponent<SelectOptionsProps & React.RefAttributes<HTMLDivElement>>;
+declare const Group$5: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    asChild?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const Label$2: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    asChild?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const Separator$5: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    asChild?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+
+type index$o_SelectContentProps = SelectContentProps;
+type index$o_SelectCreateItemProps = SelectCreateItemProps;
+type index$o_SelectFilterOption = SelectFilterOption;
+type index$o_SelectItemProps = SelectItemProps;
+type index$o_SelectItemTextProps = SelectItemTextProps;
+type index$o_SelectOption = SelectOption;
+type index$o_SelectOptionsProps = SelectOptionsProps;
+type index$o_SelectPortalProps = SelectPortalProps;
+type index$o_SelectRootProps = SelectRootProps;
+type index$o_SelectSearchInputProps = SelectSearchInputProps;
+type index$o_SelectTriggerProps = SelectTriggerProps;
+type index$o_SelectValueProps = SelectValueProps;
+declare namespace index$o {
+  export { Content$6 as Content, CreateItem$1 as CreateItem, Group$5 as Group, Icon$2 as Icon, Item$6 as Item, ItemIndicator$1 as ItemIndicator, ItemText$1 as ItemText, Label$2 as Label, Options$1 as Options, Portal$6 as Portal, Root$m as Root, SearchInput$1 as SearchInput, type index$o_SelectContentProps as SelectContentProps, type index$o_SelectCreateItemProps as SelectCreateItemProps, type index$o_SelectFilterOption as SelectFilterOption, type index$o_SelectItemProps as SelectItemProps, type index$o_SelectItemTextProps as SelectItemTextProps, type index$o_SelectOption as SelectOption, type index$o_SelectOptionsProps as SelectOptionsProps, type index$o_SelectPortalProps as SelectPortalProps, type index$o_SelectRootProps as SelectRootProps, type index$o_SelectSearchInputProps as SelectSearchInputProps, type index$o_SelectTriggerProps as SelectTriggerProps, type index$o_SelectValueProps as SelectValueProps, Separator$5 as Separator, Trigger$6 as Trigger, Value$5 as Value, Viewport$3 as Viewport };
+}
+
+interface MultiSelectFilterOption {
+    value: string;
+    textValue: string;
+}
+interface MultiSelectOption {
+    value: string;
+    label: React.ReactNode;
+    textValue?: string;
+    disabled?: boolean;
+}
+interface MultiSelectSelectedOption extends MultiSelectOption {
+    textValue: string;
+}
+interface MultiSelectRootProps {
+    children?: React.ReactNode;
+    value?: string[];
+    defaultValue?: string[];
+    onValueChange?: (value: string[]) => void;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    dir?: 'ltr' | 'rtl';
+    name?: string;
+    autoComplete?: string;
+    disabled?: boolean;
+    required?: boolean;
+    searchable?: boolean;
+    searchValue?: string;
+    defaultSearchValue?: string;
+    onSearchValueChange?: (value: string) => void;
+    filterOption?: (option: MultiSelectFilterOption, searchValue: string) => boolean;
+    onCreateOption?: (value: string) => void;
+    createOptionLabel?: React.ReactNode | ((value: string) => React.ReactNode);
+    resetSearchOnClose?: boolean;
+}
+declare const Root$l: React.FC<MultiSelectRootProps>;
+interface MultiSelectTriggerProps extends React.ComponentPropsWithoutRef<'button'> {
+    asChild?: boolean;
+}
+declare const Trigger$5: React.ForwardRefExoticComponent<MultiSelectTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+interface MultiSelectValueProps extends Omit<React.ComponentPropsWithoutRef<'span'>, 'children'> {
+    asChild?: boolean;
+    placeholder?: React.ReactNode;
+    options?: MultiSelectOption[];
+    separator?: React.ReactNode;
+    children?: React.ReactNode | ((selected: MultiSelectSelectedOption[]) => React.ReactNode);
+}
+declare const Value$4: React.ForwardRefExoticComponent<MultiSelectValueProps & React.RefAttributes<HTMLSpanElement>>;
+declare const Icon$1: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+    asChild?: boolean;
+} & React.RefAttributes<HTMLSpanElement>>;
+interface MultiSelectSearchInputProps extends React.ComponentPropsWithoutRef<'input'> {
+    asChild?: boolean;
+}
+declare const SearchInput: React.ForwardRefExoticComponent<MultiSelectSearchInputProps & React.RefAttributes<HTMLInputElement>>;
+interface MultiSelectPortalProps {
+    children?: React.ReactNode;
+    container?: Element | DocumentFragment | null;
+    forceMount?: boolean;
+}
+declare const Portal$5: React.FC<MultiSelectPortalProps>;
+interface MultiSelectContentProps extends React.ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+    forceMount?: boolean;
+    position?: 'item-aligned' | 'popper';
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    sideOffset?: number;
+    align?: 'start' | 'center' | 'end';
+    alignOffset?: number;
+    avoidCollisions?: boolean;
+    collisionPadding?: number;
+    onCloseAutoFocus?: (event: Event) => void;
+    onEscapeKeyDown?: (event: KeyboardEvent) => void;
+    onPointerDownOutside?: (event: Event) => void;
+}
+declare const Content$5: React.ForwardRefExoticComponent<MultiSelectContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const Viewport$2: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    asChild?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+interface MultiSelectItemProps extends React.ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+    value: string;
+    disabled?: boolean;
+    textValue?: string;
+}
+declare const Item$5: React.ForwardRefExoticComponent<MultiSelectItemProps & React.RefAttributes<HTMLDivElement>>;
+interface MultiSelectCreateItemProps extends Omit<React.ComponentPropsWithoutRef<'div'>, 'children'> {
+    asChild?: boolean;
+    value?: string;
+    children?: React.ReactNode | ((value: string) => React.ReactNode);
+}
+declare const CreateItem: React.ForwardRefExoticComponent<MultiSelectCreateItemProps & React.RefAttributes<HTMLDivElement>>;
+interface MultiSelectItemTextProps extends React.ComponentPropsWithoutRef<'span'> {
+    asChild?: boolean;
+}
+declare const ItemText: React.ForwardRefExoticComponent<MultiSelectItemTextProps & React.RefAttributes<HTMLSpanElement>>;
+declare const ItemIndicator: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+    asChild?: boolean;
+} & React.RefAttributes<HTMLSpanElement>>;
+interface MultiSelectOptionsProps extends React.ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+    options: MultiSelectOption[];
+    itemHeight?: number;
+    overscan?: number;
+    visibleItemCount?: number;
+    emptyMessage?: React.ReactNode;
+    itemClassName?: string;
+    itemTextClassName?: string;
+    itemIndicatorClassName?: string;
+    renderOption?: (option: MultiSelectOption) => React.ReactNode;
+    renderItemIndicator?: (option: MultiSelectOption) => React.ReactNode;
+}
+declare const Options: React.ForwardRefExoticComponent<MultiSelectOptionsProps & React.RefAttributes<HTMLDivElement>>;
+declare const Group$4: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    asChild?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const Label$1: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    asChild?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const Separator$4: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    asChild?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+
+declare const index$n_CreateItem: typeof CreateItem;
+declare const index$n_ItemIndicator: typeof ItemIndicator;
+declare const index$n_ItemText: typeof ItemText;
+type index$n_MultiSelectContentProps = MultiSelectContentProps;
+type index$n_MultiSelectCreateItemProps = MultiSelectCreateItemProps;
+type index$n_MultiSelectFilterOption = MultiSelectFilterOption;
+type index$n_MultiSelectItemProps = MultiSelectItemProps;
+type index$n_MultiSelectItemTextProps = MultiSelectItemTextProps;
+type index$n_MultiSelectOption = MultiSelectOption;
+type index$n_MultiSelectOptionsProps = MultiSelectOptionsProps;
+type index$n_MultiSelectPortalProps = MultiSelectPortalProps;
+type index$n_MultiSelectRootProps = MultiSelectRootProps;
+type index$n_MultiSelectSearchInputProps = MultiSelectSearchInputProps;
+type index$n_MultiSelectSelectedOption = MultiSelectSelectedOption;
+type index$n_MultiSelectTriggerProps = MultiSelectTriggerProps;
+type index$n_MultiSelectValueProps = MultiSelectValueProps;
+declare const index$n_Options: typeof Options;
+declare const index$n_SearchInput: typeof SearchInput;
+declare namespace index$n {
+  export { Content$5 as Content, index$n_CreateItem as CreateItem, Group$4 as Group, Icon$1 as Icon, Item$5 as Item, index$n_ItemIndicator as ItemIndicator, index$n_ItemText as ItemText, Label$1 as Label, type index$n_MultiSelectContentProps as MultiSelectContentProps, type index$n_MultiSelectCreateItemProps as MultiSelectCreateItemProps, type index$n_MultiSelectFilterOption as MultiSelectFilterOption, type index$n_MultiSelectItemProps as MultiSelectItemProps, type index$n_MultiSelectItemTextProps as MultiSelectItemTextProps, type index$n_MultiSelectOption as MultiSelectOption, type index$n_MultiSelectOptionsProps as MultiSelectOptionsProps, type index$n_MultiSelectPortalProps as MultiSelectPortalProps, type index$n_MultiSelectRootProps as MultiSelectRootProps, type index$n_MultiSelectSearchInputProps as MultiSelectSearchInputProps, type index$n_MultiSelectSelectedOption as MultiSelectSelectedOption, type index$n_MultiSelectTriggerProps as MultiSelectTriggerProps, type index$n_MultiSelectValueProps as MultiSelectValueProps, index$n_Options as Options, Portal$5 as Portal, Root$l as Root, index$n_SearchInput as SearchInput, Separator$4 as Separator, Trigger$5 as Trigger, Value$4 as Value, Viewport$2 as Viewport };
+}
+
+interface ComboboxRootProps {
+    children?: React.ReactNode;
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    inputValue?: string;
+    defaultInputValue?: string;
+    onInputValueChange?: (value: string) => void;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    dir?: 'ltr' | 'rtl';
+    disabled?: boolean;
+}
+declare const Root$k: React.FC<ComboboxRootProps>;
+interface ComboboxInputProps extends React.ComponentPropsWithoutRef<'input'> {
+    asChild?: boolean;
+}
+declare const Input$8: React.ForwardRefExoticComponent<ComboboxInputProps & React.RefAttributes<HTMLInputElement>>;
+interface ComboboxPortalProps {
+    children?: React.ReactNode;
+    container?: Element | DocumentFragment | null;
+    forceMount?: boolean;
+}
+declare const Portal$4: React.FC<ComboboxPortalProps>;
+interface ComboboxContentProps extends React.ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+    forceMount?: boolean;
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    sideOffset?: number;
+    align?: 'start' | 'center' | 'end';
+    avoidCollisions?: boolean;
+    onEscapeKeyDown?: (event: KeyboardEvent) => void;
+}
+declare const Content$4: React.ForwardRefExoticComponent<ComboboxContentProps & React.RefAttributes<HTMLDivElement>>;
+interface ComboboxItemProps extends React.ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+    value: string;
+    disabled?: boolean;
+    textValue?: string;
+}
+declare const Item$4: React.ForwardRefExoticComponent<ComboboxItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const Empty$1: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const Group$3: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    asChild?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const Separator$3: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    asChild?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+
+type index$m_ComboboxContentProps = ComboboxContentProps;
+type index$m_ComboboxInputProps = ComboboxInputProps;
+type index$m_ComboboxItemProps = ComboboxItemProps;
+type index$m_ComboboxPortalProps = ComboboxPortalProps;
+type index$m_ComboboxRootProps = ComboboxRootProps;
+declare namespace index$m {
+  export { type index$m_ComboboxContentProps as ComboboxContentProps, type index$m_ComboboxInputProps as ComboboxInputProps, type index$m_ComboboxItemProps as ComboboxItemProps, type index$m_ComboboxPortalProps as ComboboxPortalProps, type index$m_ComboboxRootProps as ComboboxRootProps, Content$4 as Content, Empty$1 as Empty, Group$3 as Group, Input$8 as Input, Item$4 as Item, Portal$4 as Portal, Root$k as Root, Separator$3 as Separator };
+}
+
+type DivProps = React.ComponentPropsWithoutRef<'div'> & {
+    asChild?: boolean;
+};
+type ButtonProps = React.ComponentPropsWithoutRef<'button'> & {
+    asChild?: boolean;
+};
+declare const Box: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    asChild?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const Container$1: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    asChild?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const Stack: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    asChild?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const Grid$2: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    asChild?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const Paper: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    asChild?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const Typography: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+    asChild?: boolean;
+} & React.RefAttributes<HTMLSpanElement>>;
+declare const Link$1: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, "ref"> & {
+    asChild?: boolean;
+} & React.RefAttributes<HTMLAnchorElement>>;
+declare const SvgIcon: React.ForwardRefExoticComponent<Omit<React.SVGProps<SVGSVGElement>, "ref"> & {
+    title?: string;
+} & React.RefAttributes<SVGSVGElement>>;
+interface ChartProps extends Omit<React.ComponentPropsWithoutRef<'svg'>, 'children'> {
+    data: number[];
+    type?: 'bar' | 'line';
+    title?: string;
+}
+declare const Chart: React.ForwardRefExoticComponent<ChartProps & React.RefAttributes<SVGSVGElement>>;
+declare const ChipRoot: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+    asChild?: boolean;
+} & React.RefAttributes<HTMLSpanElement>>;
+declare const ChipLabel: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+    asChild?: boolean;
+} & React.RefAttributes<HTMLSpanElement>>;
+declare const ChipDelete: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+    asChild?: boolean;
+} & React.RefAttributes<HTMLButtonElement>>;
+declare const ButtonGroup: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    asChild?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const FloatingActionButton: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+    asChild?: boolean;
+} & React.RefAttributes<HTMLButtonElement>>;
+interface RatingProps extends Omit<React.ComponentPropsWithoutRef<'div'>, 'defaultValue' | 'onChange'> {
+    value?: number;
+    defaultValue?: number;
+    onValueChange?: (value: number) => void;
+    max?: number;
+    disabled?: boolean;
+    readOnly?: boolean;
+    name?: string;
+    itemClassName?: string;
+    icon?: React.ReactNode;
+    emptyIcon?: React.ReactNode;
+    getLabelText?: (value: number) => string;
+}
+declare const Rating: React.ForwardRefExoticComponent<RatingProps & React.RefAttributes<HTMLDivElement>>;
+declare const Autocomplete: {
+    Root: React.FC<ComboboxRootProps>;
+    Input: React.ForwardRefExoticComponent<ComboboxInputProps & React.RefAttributes<HTMLInputElement>>;
+    Portal: React.FC<ComboboxPortalProps>;
+    Content: React.ForwardRefExoticComponent<ComboboxContentProps & React.RefAttributes<HTMLDivElement>>;
+    Item: React.ForwardRefExoticComponent<ComboboxItemProps & React.RefAttributes<HTMLDivElement>>;
+    Empty: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    Group: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        asChild?: boolean;
+    } & React.RefAttributes<HTMLDivElement>>;
+};
+interface TransferListOption {
+    value: string;
+    label: React.ReactNode;
+    disabled?: boolean;
+}
+interface TransferListProps extends Omit<React.ComponentPropsWithoutRef<'div'>, 'defaultValue' | 'onChange'> {
+    options: TransferListOption[];
+    value?: string[];
+    defaultValue?: string[];
+    onValueChange?: (value: string[]) => void;
+    sourceTitle?: React.ReactNode;
+    targetTitle?: React.ReactNode;
+}
+declare const TransferList: React.ForwardRefExoticComponent<TransferListProps & React.RefAttributes<HTMLDivElement>>;
+declare const List$2: {
+    Root: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & React.RefAttributes<HTMLUListElement>>;
+    Item: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React.RefAttributes<HTMLLIElement>>;
+    ItemButton: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+        asChild?: boolean;
+    } & React.RefAttributes<HTMLButtonElement>>;
+    ItemText: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+        asChild?: boolean;
+    } & React.RefAttributes<HTMLSpanElement>>;
+    ItemIcon: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+        asChild?: boolean;
+    } & React.RefAttributes<HTMLSpanElement>>;
+    ItemAvatar: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+        asChild?: boolean;
+    } & React.RefAttributes<HTMLSpanElement>>;
+    ItemSecondaryAction: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        asChild?: boolean;
+    } & React.RefAttributes<HTMLDivElement>>;
+    Subheader: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React.RefAttributes<HTMLLIElement>>;
+};
+declare const ImageList: {
+    Root: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & React.RefAttributes<HTMLUListElement>>;
+    Item: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React.RefAttributes<HTMLLIElement>>;
+    Image: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>, "ref"> & React.RefAttributes<HTMLImageElement>>;
+    Caption: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        asChild?: boolean;
+    } & React.RefAttributes<HTMLDivElement>>;
+};
+declare const Table: {
+    Root: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.TableHTMLAttributes<HTMLTableElement>, HTMLTableElement>, "ref"> & React.RefAttributes<HTMLTableElement>>;
+    Header: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>, "ref"> & React.RefAttributes<HTMLTableSectionElement>>;
+    Body: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>, "ref"> & React.RefAttributes<HTMLTableSectionElement>>;
+    Footer: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>, "ref"> & React.RefAttributes<HTMLTableSectionElement>>;
+    Row: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>, "ref"> & React.RefAttributes<HTMLTableRowElement>>;
+    Head: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ThHTMLAttributes<HTMLTableHeaderCellElement>, HTMLTableHeaderCellElement>, "ref"> & React.RefAttributes<HTMLTableHeaderCellElement>>;
+    Cell: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.TdHTMLAttributes<HTMLTableDataCellElement>, HTMLTableDataCellElement>, "ref"> & React.RefAttributes<HTMLTableDataCellElement>>;
+    Caption: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
+};
+interface BackdropProps extends DivProps {
+    open?: boolean;
+    forceMount?: boolean;
+    invisible?: boolean;
+}
+declare const Backdrop: React.ForwardRefExoticComponent<BackdropProps & React.RefAttributes<HTMLDivElement>>;
+interface SnackbarOrigin {
+    vertical: 'top' | 'bottom';
+    horizontal: 'left' | 'center' | 'right';
+}
+type SnackbarCloseReason = 'timeout' | 'clickaway' | 'escapeKeyDown';
+interface SnackbarProps extends Omit<DivProps, 'defaultValue' | 'onChange'> {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    autoHideDuration?: number;
+    resumeHideDuration?: number;
+    disableWindowBlurListener?: boolean;
+    anchorOrigin?: SnackbarOrigin;
+    message?: React.ReactNode;
+    action?: React.ReactNode;
+    onClose?: (event: Event | React.SyntheticEvent | null, reason: SnackbarCloseReason) => void;
+}
+declare const Snackbar: React.ForwardRefExoticComponent<SnackbarProps & React.RefAttributes<HTMLDivElement>>;
+type ModalCloseReason = 'escapeKeyDown' | 'backdropClick';
+interface ModalProps extends Omit<DivProps, 'defaultValue' | 'onChange'> {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    onClose?: (event: KeyboardEvent | React.PointerEvent<HTMLDivElement>, reason: ModalCloseReason) => void;
+    container?: Element | DocumentFragment | null;
+    closeOnEscape?: boolean;
+    closeOnPointerDownOutside?: boolean;
+}
+declare const Modal: React.ForwardRefExoticComponent<ModalProps & React.RefAttributes<HTMLDivElement>>;
+declare const AppBar: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
+interface BottomNavigationRootProps extends Omit<React.ComponentPropsWithoutRef<'nav'>, 'defaultValue' | 'onChange'> {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    showLabels?: boolean;
+}
+interface BottomNavigationItemProps extends ButtonProps {
+    value: string;
+    icon?: React.ReactNode;
+    label?: React.ReactNode;
+    showLabel?: boolean;
+}
+declare const BottomNavigation: {
+    Root: React.ForwardRefExoticComponent<BottomNavigationRootProps & React.RefAttributes<HTMLElement>>;
+    Item: React.ForwardRefExoticComponent<BottomNavigationItemProps & React.RefAttributes<HTMLButtonElement>>;
+};
+interface SpeedDialRootProps extends Omit<React.ComponentPropsWithoutRef<'div'>, 'defaultValue' | 'onChange'> {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    direction?: 'up' | 'down' | 'left' | 'right';
+    hidden?: boolean;
+}
+interface SpeedDialTriggerProps extends ButtonProps {
+    icon?: React.ReactNode;
+    openIcon?: React.ReactNode;
+}
+declare const SpeedDial: {
+    Root: React.ForwardRefExoticComponent<SpeedDialRootProps & React.RefAttributes<HTMLDivElement>>;
+    Trigger: React.ForwardRefExoticComponent<SpeedDialTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+    Content: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        asChild?: boolean;
+    } & React.RefAttributes<HTMLDivElement>>;
+    Action: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+        asChild?: boolean;
+    } & React.RefAttributes<HTMLButtonElement>>;
+};
+declare const Masonry: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    asChild?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const Timeline: {
+    Root: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & React.RefAttributes<HTMLUListElement>>;
+    Item: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React.RefAttributes<HTMLLIElement>>;
+    Separator: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        asChild?: boolean;
+    } & React.RefAttributes<HTMLDivElement>>;
+    Dot: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+        asChild?: boolean;
+    } & React.RefAttributes<HTMLSpanElement>>;
+    Content: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        asChild?: boolean;
+    } & React.RefAttributes<HTMLDivElement>>;
+};
+interface ClickAwayListenerProps {
+    children?: React.ReactNode;
+    onClickAway?: (event: MouseEvent | TouchEvent) => void;
+}
+declare const ClickAwayListener: React.ForwardRefExoticComponent<ClickAwayListenerProps & React.RefAttributes<HTMLSpanElement>>;
+declare const NoSsr: React.FC<{
+    children?: React.ReactNode;
+    fallback?: React.ReactNode;
+    defer?: boolean;
+}>;
+declare const Portal$3: React.ForwardRefExoticComponent<_structyl_core.PortalProps & React.RefAttributes<HTMLDivElement>>;
+interface PopperProps {
+    open: boolean;
+    anchorEl?: Element | null | (() => Element | null);
+    placement?: 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'left-start' | 'left-end' | 'right' | 'right-start' | 'right-end';
+    children?: React.ReactNode;
+    className?: string;
+    style?: React.CSSProperties;
+    keepMounted?: boolean;
+    disablePortal?: boolean;
+    container?: Element | DocumentFragment | null;
+}
+declare const Popper: React.ForwardRefExoticComponent<PopperProps & React.RefAttributes<HTMLDivElement>>;
+interface TextareaAutosizeProps extends React.TextareaHTMLAttributes<HTMLTextAreaElement> {
+    minRows?: number;
+    maxRows?: number;
+}
+declare const TextareaAutosize: React.ForwardRefExoticComponent<TextareaAutosizeProps & React.RefAttributes<HTMLTextAreaElement>>;
+type TransitionStatus = 'entering' | 'entered' | 'exiting' | 'exited';
+interface TransitionProps extends Omit<DivProps, 'children'> {
+    in?: boolean;
+    appear?: boolean;
+    mountOnEnter?: boolean;
+    unmountOnExit?: boolean;
+    timeout?: number | {
+        appear?: number;
+        enter?: number;
+        exit?: number;
+    };
+    onEnter?: () => void;
+    onEntering?: () => void;
+    onEntered?: () => void;
+    onExit?: () => void;
+    onExiting?: () => void;
+    onExited?: () => void;
+    children?: React.ReactNode | ((status: TransitionStatus) => React.ReactNode);
+}
+declare const Transition: React.ForwardRefExoticComponent<TransitionProps & React.RefAttributes<HTMLDivElement>>;
+declare const CssBaseline: React.FC<{
+    children?: React.ReactNode;
+    enableColorScheme?: boolean;
+}>;
+interface InitColorSchemeScriptProps {
+    storageKey?: string;
+    defaultMode?: 'light' | 'dark' | 'system';
+    attribute?: string;
+}
+declare const InitColorSchemeScript: React.FC<InitColorSchemeScriptProps>;
+
+declare const index$l_AppBar: typeof AppBar;
+declare const index$l_Autocomplete: typeof Autocomplete;
+declare const index$l_Backdrop: typeof Backdrop;
+type index$l_BackdropProps = BackdropProps;
+declare const index$l_BottomNavigation: typeof BottomNavigation;
+type index$l_BottomNavigationItemProps = BottomNavigationItemProps;
+type index$l_BottomNavigationRootProps = BottomNavigationRootProps;
+declare const index$l_Box: typeof Box;
+declare const index$l_ButtonGroup: typeof ButtonGroup;
+declare const index$l_Chart: typeof Chart;
+type index$l_ChartProps = ChartProps;
+declare const index$l_ChipDelete: typeof ChipDelete;
+declare const index$l_ChipLabel: typeof ChipLabel;
+declare const index$l_ChipRoot: typeof ChipRoot;
+declare const index$l_ClickAwayListener: typeof ClickAwayListener;
+type index$l_ClickAwayListenerProps = ClickAwayListenerProps;
+declare const index$l_CssBaseline: typeof CssBaseline;
+declare const index$l_FloatingActionButton: typeof FloatingActionButton;
+declare const index$l_ImageList: typeof ImageList;
+declare const index$l_InitColorSchemeScript: typeof InitColorSchemeScript;
+type index$l_InitColorSchemeScriptProps = InitColorSchemeScriptProps;
+declare const index$l_Masonry: typeof Masonry;
+declare const index$l_Modal: typeof Modal;
+type index$l_ModalCloseReason = ModalCloseReason;
+type index$l_ModalProps = ModalProps;
+declare const index$l_NoSsr: typeof NoSsr;
+declare const index$l_Paper: typeof Paper;
+declare const index$l_Popper: typeof Popper;
+type index$l_PopperProps = PopperProps;
+declare const index$l_Rating: typeof Rating;
+type index$l_RatingProps = RatingProps;
+declare const index$l_Snackbar: typeof Snackbar;
+type index$l_SnackbarCloseReason = SnackbarCloseReason;
+type index$l_SnackbarOrigin = SnackbarOrigin;
+type index$l_SnackbarProps = SnackbarProps;
+declare const index$l_SpeedDial: typeof SpeedDial;
+type index$l_SpeedDialRootProps = SpeedDialRootProps;
+type index$l_SpeedDialTriggerProps = SpeedDialTriggerProps;
+declare const index$l_Stack: typeof Stack;
+declare const index$l_SvgIcon: typeof SvgIcon;
+declare const index$l_Table: typeof Table;
+declare const index$l_TextareaAutosize: typeof TextareaAutosize;
+type index$l_TextareaAutosizeProps = TextareaAutosizeProps;
+declare const index$l_Timeline: typeof Timeline;
+declare const index$l_TransferList: typeof TransferList;
+type index$l_TransferListOption = TransferListOption;
+type index$l_TransferListProps = TransferListProps;
+declare const index$l_Transition: typeof Transition;
+type index$l_TransitionProps = TransitionProps;
+declare const index$l_Typography: typeof Typography;
+declare namespace index$l {
+  export { index$l_AppBar as AppBar, index$l_Autocomplete as Autocomplete, index$l_Backdrop as Backdrop, type index$l_BackdropProps as BackdropProps, index$l_BottomNavigation as BottomNavigation, type index$l_BottomNavigationItemProps as BottomNavigationItemProps, type index$l_BottomNavigationRootProps as BottomNavigationRootProps, index$l_Box as Box, index$l_ButtonGroup as ButtonGroup, index$l_Chart as Chart, type index$l_ChartProps as ChartProps, index$l_ChipDelete as ChipDelete, index$l_ChipLabel as ChipLabel, index$l_ChipRoot as ChipRoot, index$l_ClickAwayListener as ClickAwayListener, type index$l_ClickAwayListenerProps as ClickAwayListenerProps, Container$1 as Container, index$l_CssBaseline as CssBaseline, index$l_FloatingActionButton as FloatingActionButton, Grid$2 as Grid, index$l_ImageList as ImageList, index$l_InitColorSchemeScript as InitColorSchemeScript, type index$l_InitColorSchemeScriptProps as InitColorSchemeScriptProps, Link$1 as Link, List$2 as List, index$l_Masonry as Masonry, index$l_Modal as Modal, type index$l_ModalCloseReason as ModalCloseReason, type index$l_ModalProps as ModalProps, index$l_NoSsr as NoSsr, index$l_Paper as Paper, index$l_Popper as Popper, type index$l_PopperProps as PopperProps, Portal$3 as Portal, index$l_Rating as Rating, type index$l_RatingProps as RatingProps, index$l_Snackbar as Snackbar, type index$l_SnackbarCloseReason as SnackbarCloseReason, type index$l_SnackbarOrigin as SnackbarOrigin, type index$l_SnackbarProps as SnackbarProps, index$l_SpeedDial as SpeedDial, type index$l_SpeedDialRootProps as SpeedDialRootProps, type index$l_SpeedDialTriggerProps as SpeedDialTriggerProps, index$l_Stack as Stack, index$l_SvgIcon as SvgIcon, index$l_Table as Table, index$l_TextareaAutosize as TextareaAutosize, type index$l_TextareaAutosizeProps as TextareaAutosizeProps, index$l_Timeline as Timeline, index$l_TransferList as TransferList, type index$l_TransferListOption as TransferListOption, type index$l_TransferListProps as TransferListProps, index$l_Transition as Transition, type index$l_TransitionProps as TransitionProps, index$l_Typography as Typography };
+}
+
+type Score = (value: string, search: string, keywords?: string[]) => number;
+interface CommandRootProps extends React.ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    filter?: Score;
+    shouldFilter?: boolean;
+    label?: string;
+    loop?: boolean;
+}
+declare const Root$j: React.ForwardRefExoticComponent<CommandRootProps & React.RefAttributes<HTMLDivElement>>;
+interface CommandInputProps extends React.ComponentPropsWithoutRef<'input'> {
+    asChild?: boolean;
+}
+declare const Input$7: React.ForwardRefExoticComponent<CommandInputProps & React.RefAttributes<HTMLInputElement>>;
+declare const List$1: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    asChild?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+interface CommandItemProps extends Omit<React.ComponentPropsWithoutRef<'div'>, 'onSelect'> {
+    asChild?: boolean;
+    value?: string;
+    keywords?: string[];
+    disabled?: boolean;
+    onSelect?: (value: string) => void;
+}
+declare const Item$3: React.ForwardRefExoticComponent<CommandItemProps & React.RefAttributes<HTMLDivElement>>;
+interface CommandGroupProps extends React.ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+    heading?: React.ReactNode;
+    value?: string;
+}
+declare const Group$2: React.ForwardRefExoticComponent<CommandGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const Empty: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const Separator$2: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    asChild?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const Loading$3: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    progress?: number;
+} & React.RefAttributes<HTMLDivElement>>;
+
+type index$k_CommandGroupProps = CommandGroupProps;
+type index$k_CommandInputProps = CommandInputProps;
+type index$k_CommandItemProps = CommandItemProps;
+type index$k_CommandRootProps = CommandRootProps;
+declare const index$k_Empty: typeof Empty;
+declare namespace index$k {
+  export { type index$k_CommandGroupProps as CommandGroupProps, type index$k_CommandInputProps as CommandInputProps, type index$k_CommandItemProps as CommandItemProps, type index$k_CommandRootProps as CommandRootProps, index$k_Empty as Empty, Group$2 as Group, Input$7 as Input, Item$3 as Item, List$1 as List, Loading$3 as Loading, Root$j as Root, Separator$2 as Separator };
+}
+
+interface OtpRootProps extends React.ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+    length?: number;
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    type?: 'numeric' | 'alphanumeric';
+    mask?: boolean;
+    autoSubmit?: boolean;
+    disabled?: boolean;
+    onComplete?: (value: string) => void;
+}
+declare const Root$i: React.ForwardRefExoticComponent<OtpRootProps & React.RefAttributes<HTMLDivElement>>;
+interface OtpInputProps extends React.ComponentPropsWithoutRef<'input'> {
+    index: number;
+}
+declare const Input$6: React.ForwardRefExoticComponent<OtpInputProps & React.RefAttributes<HTMLInputElement>>;
+declare const HiddenInput: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref"> & {
+    name?: string;
+} & React.RefAttributes<HTMLInputElement>>;
+
+declare const index$j_HiddenInput: typeof HiddenInput;
+type index$j_OtpInputProps = OtpInputProps;
+type index$j_OtpRootProps = OtpRootProps;
+declare namespace index$j {
+  export { index$j_HiddenInput as HiddenInput, Input$6 as Input, type index$j_OtpInputProps as OtpInputProps, type index$j_OtpRootProps as OtpRootProps, Root$i as Root };
+}
+
+interface PasswordToggleFieldRootProps extends React.ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+    visible?: boolean;
+    defaultVisible?: boolean;
+    onVisibleChange?: (visible: boolean) => void;
+}
+declare const Root$h: React.ForwardRefExoticComponent<PasswordToggleFieldRootProps & React.RefAttributes<HTMLDivElement>>;
+declare const Input$5: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>>;
+declare const Toggle$1: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const Icon: React.FC<{
+    visible?: React.ReactNode;
+    hidden?: React.ReactNode;
+}>;
+
+declare const index$i_Icon: typeof Icon;
+type index$i_PasswordToggleFieldRootProps = PasswordToggleFieldRootProps;
+declare namespace index$i {
+  export { index$i_Icon as Icon, Input$5 as Input, type index$i_PasswordToggleFieldRootProps as PasswordToggleFieldRootProps, Root$h as Root, Toggle$1 as Toggle };
+}
+
+interface NumberFieldRootProps extends Omit<React.ComponentPropsWithoutRef<'div'>, 'onChange'> {
+    asChild?: boolean;
+    value?: number;
+    defaultValue?: number;
+    onValueChange?: (value: number | undefined) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    disabled?: boolean;
+    readOnly?: boolean;
+    formatOptions?: Intl.NumberFormatOptions;
+    locale?: string;
+}
+declare const Root$g: React.ForwardRefExoticComponent<NumberFieldRootProps & React.RefAttributes<HTMLDivElement>>;
+declare const Input$4: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>>;
+declare const IncrementTrigger: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const DecrementTrigger: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+
+declare const index$h_DecrementTrigger: typeof DecrementTrigger;
+declare const index$h_IncrementTrigger: typeof IncrementTrigger;
+type index$h_NumberFieldRootProps = NumberFieldRootProps;
+declare namespace index$h {
+  export { index$h_DecrementTrigger as DecrementTrigger, index$h_IncrementTrigger as IncrementTrigger, Input$4 as Input, type index$h_NumberFieldRootProps as NumberFieldRootProps, Root$g as Root };
+}
+
+type CalendarMode = 'single' | 'range' | 'multiple';
+interface CalendarDateRange {
+    from?: Date;
+    to?: Date;
+}
+type CalendarSelectedValue = Date | Date[] | CalendarDateRange | undefined;
+interface CalendarRootProps extends Omit<React.ComponentPropsWithoutRef<'div'>, 'onSelect'> {
+    asChild?: boolean;
+    mode?: CalendarMode;
+    selected?: CalendarSelectedValue;
+    defaultSelected?: CalendarSelectedValue;
+    onSelect?: (value: CalendarSelectedValue) => void;
+    month?: Date;
+    defaultMonth?: Date;
+    onMonthChange?: (month: Date) => void;
+    minDate?: Date;
+    maxDate?: Date;
+    disablePast?: boolean;
+    disableFuture?: boolean;
+    disabled?: boolean;
+    disabledDays?: (date: Date) => boolean;
+    shouldDisableDate?: (date: Date) => boolean;
+    shouldDisableMonth?: (date: Date) => boolean;
+    shouldDisableYear?: (date: Date) => boolean;
+    weekStartsOn?: number;
+    locale?: string;
+    disableHighlightToday?: boolean;
+    displayWeekNumber?: boolean;
+    fixedWeekNumber?: number;
+    showDaysOutsideCurrentMonth?: boolean;
+    dayOfWeekFormatter?: (date: Date) => string;
+    onYearChange?: (year: Date) => void;
+}
+declare const Root$f: React.ForwardRefExoticComponent<CalendarRootProps & React.RefAttributes<HTMLDivElement>>;
+declare const Header$1: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const PreviousButton: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const NextButton: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const Heading: React.FC<{
+    format?: Intl.DateTimeFormatOptions;
+    locale?: string;
+}>;
+declare const Grid$1: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableElement> & React.RefAttributes<HTMLTableElement>>;
+declare const GridHead: React.FC<{
+    locale?: string;
+    format?: 'narrow' | 'short' | 'long';
+}>;
+interface GridBodyProps {
+    children: (date: Date, props: {
+        isOutsideMonth: boolean;
+    }) => React.ReactNode;
+}
+declare const GridBody: React.FC<GridBodyProps>;
+interface CalendarDayProps extends React.ComponentPropsWithoutRef<'button'> {
+    date: Date;
+    isOutsideMonth?: boolean;
+}
+declare const Day: React.ForwardRefExoticComponent<CalendarDayProps & React.RefAttributes<HTMLButtonElement>>;
+
+type index$g_CalendarDateRange = CalendarDateRange;
+type index$g_CalendarRootProps = CalendarRootProps;
+declare const index$g_Day: typeof Day;
+declare const index$g_GridBody: typeof GridBody;
+declare const index$g_GridHead: typeof GridHead;
+declare const index$g_Heading: typeof Heading;
+declare const index$g_NextButton: typeof NextButton;
+declare const index$g_PreviousButton: typeof PreviousButton;
+declare namespace index$g {
+  export { type index$g_CalendarDateRange as CalendarDateRange, type index$g_CalendarRootProps as CalendarRootProps, index$g_Day as Day, Grid$1 as Grid, index$g_GridBody as GridBody, index$g_GridHead as GridHead, Header$1 as Header, index$g_Heading as Heading, index$g_NextButton as NextButton, index$g_PreviousButton as PreviousButton, Root$f as Root };
+}
+
+type PickerChangeSource = 'field' | 'view' | 'shortcut' | 'unknown';
+interface PickerShortcutMetadata {
+    label?: React.ReactNode;
+    value?: unknown;
+}
+interface PickerChangeContext<TError> {
+    validationError: TError | null;
+    source: PickerChangeSource;
+    shortcut?: PickerShortcutMetadata;
+}
+type PickerFieldSection = 'day' | 'empty' | 'hours' | 'meridiem' | 'minutes' | 'month' | 'seconds' | 'weekDay' | 'year';
+type PickerSelectedSections = 'all' | PickerFieldSection | number | null;
+type PickerOrientation = 'landscape' | 'portrait';
+type PickerFormatDensity = 'dense' | 'spacious';
+type DatePickerView = 'day' | 'month' | 'year';
+type TimePickerView = 'hours' | 'minutes' | 'seconds' | 'meridiem';
+type DateTimePickerView = DatePickerView | TimePickerView;
+type DateRangePosition = 'start' | 'end';
+type PickerSxValue = boolean | Record<string, unknown> | ((theme: unknown) => Record<string, unknown> | null | undefined);
+type PickerSx = PickerSxValue | PickerSxValue[];
+type PickerSlots = Record<string, React.ElementType | null | undefined>;
+type PickerSlotProps = Record<string, unknown>;
+type PickerLocaleText = Record<string, React.ReactNode>;
+type DateValidationError = 'invalidDate' | 'disablePast' | 'disableFuture' | 'minDate' | 'maxDate' | 'shouldDisableDate' | 'shouldDisableMonth' | 'shouldDisableYear';
+type TimeValidationError = 'invalidDate' | 'disablePast' | 'disableFuture' | 'minTime' | 'maxTime' | 'minutesStep' | 'shouldDisableTime';
+type DateTimeValidationError = DateValidationError | TimeValidationError | 'minDateTime' | 'maxDateTime';
+type DateRangeValidationError = DateValidationError | 'invalidRange';
+interface DateValidationOptions {
+    minDate?: Date;
+    maxDate?: Date;
+    disablePast?: boolean;
+    disableFuture?: boolean;
+    shouldDisableDate?: (date: Date) => boolean;
+    shouldDisableMonth?: (date: Date) => boolean;
+    shouldDisableYear?: (date: Date) => boolean;
+}
+interface TimeValidationOptions {
+    minTime?: Date;
+    maxTime?: Date;
+    disablePast?: boolean;
+    disableFuture?: boolean;
+    minutesStep?: number;
+    disableIgnoringDatePartForTimeValidation?: boolean;
+    shouldDisableTime?: (value: Date, view: TimePickerView) => boolean;
+}
+interface DateTimeValidationOptions extends DateValidationOptions, TimeValidationOptions {
+    minDateTime?: Date;
+    maxDateTime?: Date;
+}
+interface TimeSteps {
+    hours?: number;
+    minutes?: number;
+    seconds?: number;
+}
+interface TimeValue$2 {
+    hour: number;
+    minute: number;
+    second?: number;
+    period?: 'am' | 'pm';
+}
+declare const DEFAULT_MIN_DATE: Date;
+declare const DEFAULT_MAX_DATE: Date;
+declare function isValidDate(value: Date | null | undefined): value is Date;
+declare function startOfDay(date: Date): Date;
+declare function startOfMonth(date: Date): Date;
+declare function addDays(date: Date, amount: number): Date;
+declare function addMonths(date: Date, amount: number): Date;
+declare function isSameDay(a: Date, b: Date): boolean;
+declare function isSameMonth(a: Date, b: Date): boolean;
+declare function isBeforeDay(a: Date, b: Date): boolean;
+declare function isAfterDay(a: Date, b: Date): boolean;
+declare function clampDate(date: Date, minDate?: Date, maxDate?: Date): Date;
+declare function createPickerChangeContext<TError>(validationError: TError | null, source: PickerChangeSource, shortcut?: PickerShortcutMetadata): PickerChangeContext<TError>;
+declare function validateDateValue(value: Date | null | undefined, options?: DateValidationOptions): DateValidationError | null;
+declare function validateTimeValue(value: Date | null | undefined, options?: TimeValidationOptions): TimeValidationError | null;
+declare function validateDateTimeValue(value: Date | null | undefined, options?: DateTimeValidationOptions): DateTimeValidationError | null;
+declare function timeValueToDate(value: TimeValue$2, referenceDate?: Date): Date;
+declare function dateToTimeValue(value: Date, hour12?: boolean): TimeValue$2;
+declare function mergeDateAndTime(datePart: Date, timePart: Date): Date;
+declare function applyTimePart(value: Date | null | undefined, part: Partial<TimeValue$2>, referenceDate?: Date): Date;
+declare function pad(value: number): string;
+
+type DatePickerFormat$1 = Intl.DateTimeFormatOptions | string;
+type DatePickerViewRenderer$1 = (params: {
+    view: DatePickerView;
+    value: Date | null;
+    onChange: (value: Date | null) => void;
+}) => React.ReactNode;
+interface DatePickerRootProps$1 {
+    children?: React.ReactNode;
+    value?: Date | null;
+    defaultValue?: Date | null;
+    onChange?: (date: Date | null, context: PickerChangeContext<DateValidationError>) => void;
+    onValueChange?: (date: Date | undefined) => void;
+    onAccept?: (date: Date | null, context: PickerChangeContext<DateValidationError>) => void;
+    onError?: (error: DateValidationError | null, value: Date | null) => void;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    onOpen?: () => void;
+    onClose?: () => void;
+    closeOnSelect?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    minDate?: Date;
+    maxDate?: Date;
+    disablePast?: boolean;
+    disableFuture?: boolean;
+    disabledDays?: (date: Date) => boolean;
+    shouldDisableDate?: (date: Date) => boolean;
+    shouldDisableMonth?: (date: Date) => boolean;
+    shouldDisableYear?: (date: Date) => boolean;
+    weekStartsOn?: number;
+    locale?: string;
+    autoFocus?: boolean;
+    dayOfWeekFormatter?: (date: Date) => string;
+    desktopModeMediaQuery?: string;
+    disableHighlightToday?: boolean;
+    disableOpenPicker?: boolean;
+    displayWeekNumber?: boolean;
+    fixedWeekNumber?: number;
+    format?: DatePickerFormat$1;
+    formatDensity?: PickerFormatDensity;
+    inputRef?: React.Ref<HTMLInputElement>;
+    keepOpenDuringFieldFocus?: boolean;
+    label?: React.ReactNode;
+    loading?: boolean;
+    localeText?: PickerLocaleText;
+    monthsPerRow?: 3 | 4;
+    name?: string;
+    onMonthChange?: (month: Date) => void;
+    onSelectedSectionsChange?: (newValue: PickerSelectedSections) => void;
+    onViewChange?: (view: DatePickerView) => void;
+    onYearChange?: (year: Date) => void;
+    openTo?: DatePickerView;
+    orientation?: PickerOrientation;
+    reduceAnimations?: boolean;
+    referenceDate?: Date;
+    renderLoading?: () => React.ReactNode;
+    selectedSections?: PickerSelectedSections;
+    defaultSelectedSections?: PickerSelectedSections;
+    showDaysOutsideCurrentMonth?: boolean;
+    slotProps?: PickerSlotProps;
+    slots?: PickerSlots;
+    sx?: PickerSx;
+    timezone?: string;
+    view?: DatePickerView;
+    defaultView?: DatePickerView;
+    viewRenderers?: Partial<Record<DatePickerView, DatePickerViewRenderer$1 | null>>;
+    views?: DatePickerView[];
+    yearsOrder?: 'asc' | 'desc';
+    yearsPerRow?: 3 | 4;
+}
+declare const Root$e: React.FC<DatePickerRootProps$1>;
+declare const Trigger$4: React.ForwardRefExoticComponent<PopoverTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const Portal$2: React.FC<PopoverPortalProps>;
+declare const Anchor$2: React.ForwardRefExoticComponent<PopoverAnchorProps & React.RefAttributes<HTMLDivElement>>;
+declare const Content$3: React.ForwardRefExoticComponent<Omit<PopoverContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const Calendar$2: React.ForwardRefExoticComponent<Omit<CalendarRootProps, "onSelect" | "mode" | "selected"> & React.RefAttributes<HTMLDivElement>>;
+declare const Loading$2: React.FC;
+declare const Value$3: React.FC<{
+    format?: DatePickerFormat$1;
+    formatDensity?: PickerFormatDensity;
+    locale?: string;
+    placeholder?: React.ReactNode;
+}>;
+
+type DatePickerFormat = Intl.DateTimeFormatOptions | string;
+type DatePickerViewRenderer = (params: {
+    view: DatePickerView;
+    value: Date | null;
+    onChange: (value: Date | null) => void;
+}) => React.ReactNode;
+interface DatePickerRootProps {
+    children?: React.ReactNode;
+    value?: Date | null;
+    defaultValue?: Date | null;
+    onChange?: (date: Date | null, context: PickerChangeContext<DateValidationError>) => void;
+    onValueChange?: (date: Date | undefined) => void;
+    onAccept?: (date: Date | null, context: PickerChangeContext<DateValidationError>) => void;
+    onError?: (error: DateValidationError | null, value: Date | null) => void;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    onOpen?: () => void;
+    onClose?: () => void;
+    closeOnSelect?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    minDate?: Date;
+    maxDate?: Date;
+    disablePast?: boolean;
+    disableFuture?: boolean;
+    disabledDays?: (date: Date) => boolean;
+    shouldDisableDate?: (date: Date) => boolean;
+    shouldDisableMonth?: (date: Date) => boolean;
+    shouldDisableYear?: (date: Date) => boolean;
+    weekStartsOn?: number;
+    locale?: string;
+    autoFocus?: boolean;
+    dayOfWeekFormatter?: (date: Date) => string;
+    desktopModeMediaQuery?: string;
+    disableHighlightToday?: boolean;
+    disableOpenPicker?: boolean;
+    displayWeekNumber?: boolean;
+    fixedWeekNumber?: number;
+    format?: DatePickerFormat;
+    formatDensity?: PickerFormatDensity;
+    inputRef?: React.Ref<HTMLInputElement>;
+    keepOpenDuringFieldFocus?: boolean;
+    label?: React.ReactNode;
+    loading?: boolean;
+    localeText?: PickerLocaleText;
+    monthsPerRow?: 3 | 4;
+    name?: string;
+    onMonthChange?: (month: Date) => void;
+    onSelectedSectionsChange?: (newValue: PickerSelectedSections) => void;
+    onViewChange?: (view: DatePickerView) => void;
+    onYearChange?: (year: Date) => void;
+    openTo?: DatePickerView;
+    orientation?: PickerOrientation;
+    reduceAnimations?: boolean;
+    referenceDate?: Date;
+    renderLoading?: () => React.ReactNode;
+    selectedSections?: PickerSelectedSections;
+    defaultSelectedSections?: PickerSelectedSections;
+    showDaysOutsideCurrentMonth?: boolean;
+    slotProps?: PickerSlotProps;
+    slots?: PickerSlots;
+    sx?: PickerSx;
+    timezone?: string;
+    view?: DatePickerView;
+    defaultView?: DatePickerView;
+    viewRenderers?: Partial<Record<DatePickerView, DatePickerViewRenderer | null>>;
+    views?: DatePickerView[];
+    yearsOrder?: 'asc' | 'desc';
+    yearsPerRow?: 3 | 4;
+}
+interface DatePickerValueProps {
+    format?: DatePickerFormat;
+    formatDensity?: PickerFormatDensity;
+    locale?: string;
+    placeholder?: React.ReactNode;
+}
+
+type index$f_DatePickerValueProps = DatePickerValueProps;
+declare namespace index$f {
+  export { Anchor$2 as Anchor, Calendar$2 as Calendar, Content$3 as Content, type DatePickerFormat$1 as DatePickerFormat, type DatePickerRootProps$1 as DatePickerRootProps, type index$f_DatePickerValueProps as DatePickerValueProps, type DatePickerViewRenderer$1 as DatePickerViewRenderer, Loading$2 as Loading, Portal$2 as Portal, Root$e as Root, Trigger$4 as Trigger, Value$3 as Value };
+}
+
+type TimeValue$1 = TimeValue$2;
+type TimePickerValue$1 = Date | TimeValue$1 | null | undefined;
+type TimePickerFormat$1 = Intl.DateTimeFormatOptions | string;
+type TimePickerViewRenderer$1 = (params: {
+    view: TimePickerView;
+    value: Date | null;
+    onChange: (value: Date | null) => void;
+}) => React.ReactNode;
+interface TimePickerRootProps$1 extends Omit<React.ComponentPropsWithoutRef<'div'>, 'defaultValue' | 'onChange' | 'onError'> {
+    asChild?: boolean;
+    value?: TimePickerValue$1;
+    defaultValue?: TimePickerValue$1;
+    onChange?: (value: Date | null, context: PickerChangeContext<TimeValidationError>) => void;
+    onValueChange?: (v: TimeValue$1) => void;
+    onAccept?: (value: Date | null, context: PickerChangeContext<TimeValidationError>) => void;
+    onError?: (error: TimeValidationError | null, value: Date | null) => void;
+    hour12?: boolean;
+    withSeconds?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    ampm?: boolean;
+    ampmInClock?: boolean;
+    autoFocus?: boolean;
+    closeOnSelect?: boolean;
+    desktopModeMediaQuery?: string;
+    disableFuture?: boolean;
+    disableIgnoringDatePartForTimeValidation?: boolean;
+    disableOpenPicker?: boolean;
+    disablePast?: boolean;
+    format?: TimePickerFormat$1;
+    formatDensity?: PickerFormatDensity;
+    inputRef?: React.Ref<HTMLInputElement>;
+    keepOpenDuringFieldFocus?: boolean;
+    label?: React.ReactNode;
+    locale?: string;
+    localeText?: PickerLocaleText;
+    maxTime?: Date;
+    minTime?: Date;
+    minutesStep?: number;
+    name?: string;
+    onClose?: () => void;
+    onOpen?: () => void;
+    onSelectedSectionsChange?: (newValue: PickerSelectedSections) => void;
+    onViewChange?: (view: TimePickerView) => void;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    openTo?: TimePickerView;
+    orientation?: PickerOrientation;
+    readOnlyInput?: boolean;
+    reduceAnimations?: boolean;
+    referenceDate?: Date;
+    selectedSections?: PickerSelectedSections;
+    defaultSelectedSections?: PickerSelectedSections;
+    shouldDisableTime?: (value: Date, view: TimePickerView) => boolean;
+    skipDisabled?: boolean;
+    slotProps?: PickerSlotProps;
+    slots?: PickerSlots;
+    sx?: PickerSx;
+    thresholdToRenderTimeInASingleColumn?: number;
+    timeSteps?: TimeSteps;
+    timezone?: string;
+    view?: TimePickerView;
+    defaultView?: TimePickerView;
+    viewRenderers?: Partial<Record<TimePickerView, TimePickerViewRenderer$1 | null>>;
+    views?: TimePickerView[];
+}
+declare const Root$d: React.ForwardRefExoticComponent<TimePickerRootProps$1 & React.RefAttributes<HTMLDivElement>>;
+type Segment$1 = 'hour' | 'minute' | 'second' | 'period';
+interface SegmentProps$3 extends React.ComponentPropsWithoutRef<'span'> {
+    segment: Segment$1;
+}
+declare const SegmentField$1: React.ForwardRefExoticComponent<SegmentProps$3 & React.RefAttributes<HTMLSpanElement>>;
+declare const Value$2: React.FC<{
+    format?: TimePickerFormat$1;
+    locale?: string;
+    placeholder?: React.ReactNode;
+}>;
+
+type TimeValue = TimeValue$2;
+type TimePickerValue = Date | TimeValue | null | undefined;
+type TimePickerFormat = Intl.DateTimeFormatOptions | string;
+type TimePickerViewRenderer = (params: {
+    view: TimePickerView;
+    value: Date | null;
+    onChange: (value: Date | null) => void;
+}) => React.ReactNode;
+type TimePickerSegment = 'hour' | 'minute' | 'second' | 'period';
+interface TimePickerRootProps extends Omit<React.ComponentPropsWithoutRef<'div'>, 'defaultValue' | 'onChange' | 'onError'> {
+    asChild?: boolean;
+    value?: TimePickerValue;
+    defaultValue?: TimePickerValue;
+    onChange?: (value: Date | null, context: PickerChangeContext<TimeValidationError>) => void;
+    onValueChange?: (v: TimeValue) => void;
+    onAccept?: (value: Date | null, context: PickerChangeContext<TimeValidationError>) => void;
+    onError?: (error: TimeValidationError | null, value: Date | null) => void;
+    hour12?: boolean;
+    withSeconds?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    ampm?: boolean;
+    /** Reserved for future analog-clock rendering — not yet implemented. */
+    ampmInClock?: boolean;
+    autoFocus?: boolean;
+    closeOnSelect?: boolean;
+    desktopModeMediaQuery?: string;
+    disableFuture?: boolean;
+    disableIgnoringDatePartForTimeValidation?: boolean;
+    disableOpenPicker?: boolean;
+    disablePast?: boolean;
+    format?: TimePickerFormat;
+    formatDensity?: PickerFormatDensity;
+    inputRef?: React.Ref<HTMLInputElement>;
+    keepOpenDuringFieldFocus?: boolean;
+    label?: React.ReactNode;
+    locale?: string;
+    localeText?: PickerLocaleText;
+    maxTime?: Date;
+    minTime?: Date;
+    minutesStep?: number;
+    name?: string;
+    onClose?: () => void;
+    onOpen?: () => void;
+    onSelectedSectionsChange?: (newValue: PickerSelectedSections) => void;
+    onViewChange?: (view: TimePickerView) => void;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    openTo?: TimePickerView;
+    orientation?: PickerOrientation;
+    readOnlyInput?: boolean;
+    reduceAnimations?: boolean;
+    referenceDate?: Date;
+    selectedSections?: PickerSelectedSections;
+    defaultSelectedSections?: PickerSelectedSections;
+    shouldDisableTime?: (value: Date, view: TimePickerView) => boolean;
+    skipDisabled?: boolean;
+    slotProps?: PickerSlotProps;
+    slots?: PickerSlots;
+    sx?: PickerSx;
+    thresholdToRenderTimeInASingleColumn?: number;
+    timeSteps?: TimeSteps;
+    timezone?: string;
+    view?: TimePickerView;
+    defaultView?: TimePickerView;
+    viewRenderers?: Partial<Record<TimePickerView, TimePickerViewRenderer | null>>;
+    views?: TimePickerView[];
+}
+interface SegmentProps$2 extends React.ComponentPropsWithoutRef<'span'> {
+    segment: TimePickerSegment;
+}
+interface TimePickerValueProps {
+    format?: TimePickerFormat;
+    locale?: string;
+    placeholder?: React.ReactNode;
+}
+
+type index$e_TimePickerSegment = TimePickerSegment;
+type index$e_TimePickerValueProps = TimePickerValueProps;
+declare namespace index$e {
+  export { Root$d as Root, SegmentField$1 as Segment, type SegmentProps$3 as SegmentProps, type TimePickerFormat$1 as TimePickerFormat, type TimePickerRootProps$1 as TimePickerRootProps, type index$e_TimePickerSegment as TimePickerSegment, type TimePickerValue$1 as TimePickerValue, type index$e_TimePickerValueProps as TimePickerValueProps, type TimePickerViewRenderer$1 as TimePickerViewRenderer, type TimeValue$1 as TimeValue, Value$2 as Value };
+}
+
+interface DateRange$1 {
+    from?: Date;
+    to?: Date;
+}
+type DateRangeTuple$1 = [Date | null, Date | null];
+type DateRangeValue$1 = DateRange$1 | DateRangeTuple$1 | null | undefined;
+type DateRangePickerFormat$1 = Intl.DateTimeFormatOptions | string;
+interface DateRangePickerShortcut$1 {
+    label: React.ReactNode;
+    getValue: (today: Date) => DateRangeValue$1;
+    disabled?: boolean;
+    closeOnSelect?: boolean;
+}
+type DateRangePickerViewRenderer$1 = (params: {
+    value: DateRangeTuple$1;
+    onChange: (value: DateRangeTuple$1) => void;
+    rangePosition: DateRangePosition;
+}) => React.ReactNode;
+interface DateRangePickerRootProps$1 {
+    children?: React.ReactNode;
+    value?: DateRangeValue$1;
+    defaultValue?: DateRangeValue$1;
+    onChange?: (range: DateRangeTuple$1, context: PickerChangeContext<DateRangeValidationError>) => void;
+    onValueChange?: (range: DateRange$1) => void;
+    onAccept?: (range: DateRangeTuple$1, context: PickerChangeContext<DateRangeValidationError>) => void;
+    onError?: (error: DateRangeValidationError | null, value: DateRangeTuple$1) => void;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    onOpen?: () => void;
+    onClose?: () => void;
+    closeOnSelect?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    minDate?: Date;
+    maxDate?: Date;
+    disablePast?: boolean;
+    disableFuture?: boolean;
+    disabledDays?: (date: Date) => boolean;
+    shouldDisableDate?: (date: Date, position: DateRangePosition) => boolean;
+    weekStartsOn?: number;
+    locale?: string;
+    autoFocus?: boolean;
+    calendars?: 1 | 2 | 3;
+    currentMonthCalendarPosition?: 1 | 2 | 3;
+    dayOfWeekFormatter?: (date: Date) => string;
+    defaultRangePosition?: DateRangePosition;
+    desktopModeMediaQuery?: string;
+    disableAutoMonthSwitching?: boolean;
+    disableDragEditing?: boolean;
+    disableHighlightToday?: boolean;
+    disableOpenPicker?: boolean;
+    displayWeekNumber?: boolean;
+    fixedWeekNumber?: number;
+    format?: DateRangePickerFormat$1;
+    formatDensity?: PickerFormatDensity;
+    inputRef?: React.Ref<HTMLInputElement>;
+    keepOpenDuringFieldFocus?: boolean;
+    label?: React.ReactNode;
+    loading?: boolean;
+    localeText?: PickerLocaleText;
+    name?: string;
+    onMonthChange?: (month: Date) => void;
+    onRangePositionChange?: (rangePosition: DateRangePosition) => void;
+    onSelectedSectionsChange?: (newValue: PickerSelectedSections) => void;
+    rangePosition?: DateRangePosition;
+    referenceDate?: Date | DateRangeTuple$1;
+    renderLoading?: () => React.ReactNode;
+    selectedSections?: PickerSelectedSections;
+    defaultSelectedSections?: PickerSelectedSections;
+    showDaysOutsideCurrentMonth?: boolean;
+    slotProps?: PickerSlotProps;
+    slots?: PickerSlots;
+    sx?: PickerSx;
+    timezone?: string;
+    viewRenderers?: {
+        day?: DateRangePickerViewRenderer$1 | null;
+    };
+    shortcuts?: DateRangePickerShortcut$1[] | false;
+}
+declare const Root$c: React.FC<DateRangePickerRootProps$1>;
+declare const Trigger$3: React.ForwardRefExoticComponent<PopoverTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const Portal$1: React.FC<PopoverPortalProps>;
+declare const Content$2: React.ForwardRefExoticComponent<PopoverContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const Anchor$1: React.ForwardRefExoticComponent<PopoverAnchorProps & React.RefAttributes<HTMLDivElement>>;
+declare const Calendar$1: React.ForwardRefExoticComponent<Omit<CalendarRootProps, "onSelect" | "mode" | "shouldDisableDate" | "selected"> & React.RefAttributes<HTMLDivElement>>;
+declare const Shortcuts: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    shortcuts?: DateRangePickerShortcut$1[];
+} & React.RefAttributes<HTMLDivElement>>;
+declare const Loading$1: React.FC;
+declare const Value$1: React.FC<{
+    format?: DateRangePickerFormat$1;
+    formatDensity?: PickerFormatDensity;
+    locale?: string;
+    separator?: string;
+    placeholder?: React.ReactNode;
+}>;
+declare function getDefaultDateRangePickerShortcuts(): DateRangePickerShortcut$1[];
+
+interface DateRange {
+    from?: Date;
+    to?: Date;
+}
+type DateRangeTuple = [Date | null, Date | null];
+type DateRangeValue = DateRange | DateRangeTuple | null | undefined;
+type DateRangePickerFormat = Intl.DateTimeFormatOptions | string;
+interface DateRangePickerShortcut {
+    label: React.ReactNode;
+    getValue: (today: Date) => DateRangeValue;
+    disabled?: boolean;
+    closeOnSelect?: boolean;
+}
+type DateRangePickerViewRenderer = (params: {
+    value: DateRangeTuple;
+    onChange: (value: DateRangeTuple) => void;
+    rangePosition: DateRangePosition;
+}) => React.ReactNode;
+interface DateRangePickerRootProps {
+    children?: React.ReactNode;
+    value?: DateRangeValue;
+    defaultValue?: DateRangeValue;
+    onChange?: (range: DateRangeTuple, context: PickerChangeContext<DateRangeValidationError>) => void;
+    onValueChange?: (range: DateRange) => void;
+    onAccept?: (range: DateRangeTuple, context: PickerChangeContext<DateRangeValidationError>) => void;
+    onError?: (error: DateRangeValidationError | null, value: DateRangeTuple) => void;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    onOpen?: () => void;
+    onClose?: () => void;
+    closeOnSelect?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    minDate?: Date;
+    maxDate?: Date;
+    disablePast?: boolean;
+    disableFuture?: boolean;
+    disabledDays?: (date: Date) => boolean;
+    shouldDisableDate?: (date: Date, position: DateRangePosition) => boolean;
+    weekStartsOn?: number;
+    locale?: string;
+    autoFocus?: boolean;
+    calendars?: 1 | 2 | 3;
+    currentMonthCalendarPosition?: 1 | 2 | 3;
+    dayOfWeekFormatter?: (date: Date) => string;
+    defaultRangePosition?: DateRangePosition;
+    desktopModeMediaQuery?: string;
+    disableAutoMonthSwitching?: boolean;
+    disableDragEditing?: boolean;
+    disableHighlightToday?: boolean;
+    disableOpenPicker?: boolean;
+    displayWeekNumber?: boolean;
+    fixedWeekNumber?: number;
+    format?: DateRangePickerFormat;
+    formatDensity?: PickerFormatDensity;
+    inputRef?: React.Ref<HTMLInputElement>;
+    keepOpenDuringFieldFocus?: boolean;
+    label?: React.ReactNode;
+    loading?: boolean;
+    localeText?: PickerLocaleText;
+    name?: string;
+    onMonthChange?: (month: Date) => void;
+    onRangePositionChange?: (rangePosition: DateRangePosition) => void;
+    onSelectedSectionsChange?: (newValue: PickerSelectedSections) => void;
+    rangePosition?: DateRangePosition;
+    referenceDate?: Date | DateRangeTuple;
+    renderLoading?: () => React.ReactNode;
+    selectedSections?: PickerSelectedSections;
+    defaultSelectedSections?: PickerSelectedSections;
+    showDaysOutsideCurrentMonth?: boolean;
+    slotProps?: PickerSlotProps;
+    slots?: PickerSlots;
+    sx?: PickerSx;
+    timezone?: string;
+    viewRenderers?: {
+        day?: DateRangePickerViewRenderer | null;
+    };
+    shortcuts?: DateRangePickerShortcut[] | false;
+}
+interface DateRangePickerValueProps {
+    format?: DateRangePickerFormat;
+    formatDensity?: PickerFormatDensity;
+    locale?: string;
+    separator?: string;
+    placeholder?: React.ReactNode;
+}
+interface DateRangePickerShortcutsProps extends React.ComponentPropsWithoutRef<'div'> {
+    shortcuts?: DateRangePickerShortcut[];
+}
+
+type index$d_DateRangePickerShortcutsProps = DateRangePickerShortcutsProps;
+type index$d_DateRangePickerValueProps = DateRangePickerValueProps;
+declare const index$d_Shortcuts: typeof Shortcuts;
+declare const index$d_getDefaultDateRangePickerShortcuts: typeof getDefaultDateRangePickerShortcuts;
+declare namespace index$d {
+  export { Anchor$1 as Anchor, Calendar$1 as Calendar, Content$2 as Content, type DateRange$1 as DateRange, type DateRangePickerFormat$1 as DateRangePickerFormat, type DateRangePickerRootProps$1 as DateRangePickerRootProps, type DateRangePickerShortcut$1 as DateRangePickerShortcut, type index$d_DateRangePickerShortcutsProps as DateRangePickerShortcutsProps, type index$d_DateRangePickerValueProps as DateRangePickerValueProps, type DateRangePickerViewRenderer$1 as DateRangePickerViewRenderer, type DateRangeTuple$1 as DateRangeTuple, type DateRangeValue$1 as DateRangeValue, Loading$1 as Loading, Portal$1 as Portal, Root$c as Root, index$d_Shortcuts as Shortcuts, Trigger$3 as Trigger, Value$1 as Value, index$d_getDefaultDateRangePickerShortcuts as getDefaultDateRangePickerShortcuts };
+}
+
+type DateTimePickerFormat$1 = Intl.DateTimeFormatOptions | string;
+type DateTimePickerViewRenderer$1 = (params: {
+    view: DateTimePickerView;
+    value: Date | null;
+    onChange: (value: Date | null) => void;
+}) => React.ReactNode;
+interface DateTimePickerRootProps$1 {
+    children?: React.ReactNode;
+    value?: Date | null;
+    defaultValue?: Date | null;
+    onChange?: (value: Date | null, context: PickerChangeContext<DateTimeValidationError>) => void;
+    onValueChange?: (value: Date | undefined) => void;
+    onAccept?: (value: Date | null, context: PickerChangeContext<DateTimeValidationError>) => void;
+    onError?: (error: DateTimeValidationError | null, value: Date | null) => void;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    onOpen?: () => void;
+    onClose?: () => void;
+    closeOnSelect?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    minDate?: Date;
+    maxDate?: Date;
+    minDateTime?: Date;
+    maxDateTime?: Date;
+    minTime?: Date;
+    maxTime?: Date;
+    disablePast?: boolean;
+    disableFuture?: boolean;
+    disabledDays?: (date: Date) => boolean;
+    shouldDisableDate?: (date: Date) => boolean;
+    shouldDisableMonth?: (date: Date) => boolean;
+    shouldDisableYear?: (date: Date) => boolean;
+    shouldDisableTime?: (value: Date, view: TimePickerView) => boolean;
+    weekStartsOn?: number;
+    locale?: string;
+    ampm?: boolean;
+    ampmInClock?: boolean;
+    autoFocus?: boolean;
+    dayOfWeekFormatter?: (date: Date) => string;
+    desktopModeMediaQuery?: string;
+    disableHighlightToday?: boolean;
+    disableIgnoringDatePartForTimeValidation?: boolean;
+    disableOpenPicker?: boolean;
+    displayWeekNumber?: boolean;
+    fixedWeekNumber?: number;
+    format?: DateTimePickerFormat$1;
+    formatDensity?: PickerFormatDensity;
+    inputRef?: React.Ref<HTMLInputElement>;
+    keepOpenDuringFieldFocus?: boolean;
+    label?: React.ReactNode;
+    loading?: boolean;
+    localeText?: PickerLocaleText;
+    minutesStep?: number;
+    monthsPerRow?: 3 | 4;
+    name?: string;
+    onMonthChange?: (month: Date) => void;
+    onSelectedSectionsChange?: (newValue: PickerSelectedSections) => void;
+    onViewChange?: (view: DateTimePickerView) => void;
+    onYearChange?: (year: Date) => void;
+    openTo?: DateTimePickerView;
+    orientation?: PickerOrientation;
+    reduceAnimations?: boolean;
+    referenceDate?: Date;
+    renderLoading?: () => React.ReactNode;
+    selectedSections?: PickerSelectedSections;
+    defaultSelectedSections?: PickerSelectedSections;
+    showDaysOutsideCurrentMonth?: boolean;
+    skipDisabled?: boolean;
+    slotProps?: PickerSlotProps;
+    slots?: PickerSlots;
+    sx?: PickerSx;
+    thresholdToRenderTimeInASingleColumn?: number;
+    timeSteps?: TimeSteps;
+    timezone?: string;
+    view?: DateTimePickerView;
+    defaultView?: DateTimePickerView;
+    viewRenderers?: Partial<Record<DateTimePickerView, DateTimePickerViewRenderer$1 | null>>;
+    views?: DateTimePickerView[];
+    yearsOrder?: 'asc' | 'desc';
+    yearsPerRow?: 3 | 4;
+}
+declare const Root$b: React.FC<DateTimePickerRootProps$1>;
+declare const Trigger$2: React.ForwardRefExoticComponent<PopoverTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const Portal: React.FC<PopoverPortalProps>;
+declare const Anchor: React.ForwardRefExoticComponent<PopoverAnchorProps & React.RefAttributes<HTMLDivElement>>;
+declare const Content$1: React.ForwardRefExoticComponent<Omit<PopoverContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const Calendar: React.ForwardRefExoticComponent<Omit<CalendarRootProps, "onSelect" | "mode" | "selected"> & React.RefAttributes<HTMLDivElement>>;
+declare const DatePanel: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+interface TimePanelRenderProps$1 {
+    value: Date | undefined;
+    onChange: (value: Date) => void;
+    onAccept: (value: Date) => void;
+    onCancel: () => void;
+    view: DateTimePickerView;
+    setView: (view: DateTimePickerView) => void;
+}
+interface TimePanelProps$1 extends Omit<React.ComponentPropsWithoutRef<'div'>, 'children'> {
+    children?: React.ReactNode | ((props: TimePanelRenderProps$1) => React.ReactNode);
+}
+declare const TimePanel: React.ForwardRefExoticComponent<TimePanelProps$1 & React.RefAttributes<HTMLDivElement>>;
+declare const DateButton: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+type Segment = 'hour' | 'minute' | 'second' | 'period';
+interface SegmentProps$1 extends React.ComponentPropsWithoutRef<'span'> {
+    segment: Segment;
+}
+declare const SegmentField: React.ForwardRefExoticComponent<SegmentProps$1 & React.RefAttributes<HTMLSpanElement>>;
+declare const Loading: React.FC;
+declare const Value: React.FC<{
+    format?: DateTimePickerFormat$1;
+    locale?: string;
+    placeholder?: React.ReactNode;
+}>;
+
+type DateTimePickerFormat = Intl.DateTimeFormatOptions | string;
+type DateTimePickerViewRenderer = (params: {
+    view: DateTimePickerView;
+    value: Date | null;
+    onChange: (value: Date | null) => void;
+}) => React.ReactNode;
+type DateTimePickerSegment = 'hour' | 'minute' | 'second' | 'period';
+interface DateTimePickerRootProps {
+    children?: React.ReactNode;
+    value?: Date | null;
+    defaultValue?: Date | null;
+    onChange?: (value: Date | null, context: PickerChangeContext<DateTimeValidationError>) => void;
+    onValueChange?: (value: Date | undefined) => void;
+    onAccept?: (value: Date | null, context: PickerChangeContext<DateTimeValidationError>) => void;
+    onError?: (error: DateTimeValidationError | null, value: Date | null) => void;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    onOpen?: () => void;
+    onClose?: () => void;
+    closeOnSelect?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    minDate?: Date;
+    maxDate?: Date;
+    minDateTime?: Date;
+    maxDateTime?: Date;
+    minTime?: Date;
+    maxTime?: Date;
+    disablePast?: boolean;
+    disableFuture?: boolean;
+    disabledDays?: (date: Date) => boolean;
+    shouldDisableDate?: (date: Date) => boolean;
+    shouldDisableMonth?: (date: Date) => boolean;
+    shouldDisableYear?: (date: Date) => boolean;
+    shouldDisableTime?: (value: Date, view: TimePickerView) => boolean;
+    weekStartsOn?: number;
+    locale?: string;
+    ampm?: boolean;
+    ampmInClock?: boolean;
+    autoFocus?: boolean;
+    dayOfWeekFormatter?: (date: Date) => string;
+    desktopModeMediaQuery?: string;
+    disableHighlightToday?: boolean;
+    disableIgnoringDatePartForTimeValidation?: boolean;
+    disableOpenPicker?: boolean;
+    displayWeekNumber?: boolean;
+    fixedWeekNumber?: number;
+    format?: DateTimePickerFormat;
+    formatDensity?: PickerFormatDensity;
+    inputRef?: React.Ref<HTMLInputElement>;
+    keepOpenDuringFieldFocus?: boolean;
+    label?: React.ReactNode;
+    loading?: boolean;
+    localeText?: PickerLocaleText;
+    minutesStep?: number;
+    monthsPerRow?: 3 | 4;
+    name?: string;
+    onMonthChange?: (month: Date) => void;
+    onSelectedSectionsChange?: (newValue: PickerSelectedSections) => void;
+    onViewChange?: (view: DateTimePickerView) => void;
+    onYearChange?: (year: Date) => void;
+    openTo?: DateTimePickerView;
+    orientation?: PickerOrientation;
+    reduceAnimations?: boolean;
+    referenceDate?: Date;
+    renderLoading?: () => React.ReactNode;
+    selectedSections?: PickerSelectedSections;
+    defaultSelectedSections?: PickerSelectedSections;
+    showDaysOutsideCurrentMonth?: boolean;
+    skipDisabled?: boolean;
+    slotProps?: PickerSlotProps;
+    slots?: PickerSlots;
+    sx?: PickerSx;
+    thresholdToRenderTimeInASingleColumn?: number;
+    timeSteps?: TimeSteps;
+    timezone?: string;
+    view?: DateTimePickerView;
+    defaultView?: DateTimePickerView;
+    viewRenderers?: Partial<Record<DateTimePickerView, DateTimePickerViewRenderer | null>>;
+    views?: DateTimePickerView[];
+    yearsOrder?: 'asc' | 'desc';
+    yearsPerRow?: 3 | 4;
+}
+interface TimePanelRenderProps {
+    value: Date | undefined;
+    onChange: (value: Date) => void;
+    onAccept: (value: Date) => void;
+    onCancel: () => void;
+    view: DateTimePickerView;
+    setView: (view: DateTimePickerView) => void;
+}
+interface TimePanelProps extends Omit<React.ComponentPropsWithoutRef<'div'>, 'children'> {
+    children?: React.ReactNode | ((props: TimePanelRenderProps) => React.ReactNode);
+}
+interface SegmentProps extends React.ComponentPropsWithoutRef<'span'> {
+    segment: DateTimePickerSegment;
+}
+interface DateTimePickerValueProps {
+    format?: DateTimePickerFormat;
+    locale?: string;
+    placeholder?: React.ReactNode;
+}
+
+declare const index$c_Anchor: typeof Anchor;
+declare const index$c_Calendar: typeof Calendar;
+declare const index$c_DateButton: typeof DateButton;
+declare const index$c_DatePanel: typeof DatePanel;
+type index$c_DateTimePickerSegment = DateTimePickerSegment;
+type index$c_DateTimePickerValueProps = DateTimePickerValueProps;
+declare const index$c_Loading: typeof Loading;
+declare const index$c_Portal: typeof Portal;
+declare const index$c_TimePanel: typeof TimePanel;
+declare const index$c_Value: typeof Value;
+declare namespace index$c {
+  export { index$c_Anchor as Anchor, index$c_Calendar as Calendar, Content$1 as Content, index$c_DateButton as DateButton, index$c_DatePanel as DatePanel, type DateTimePickerFormat$1 as DateTimePickerFormat, type DateTimePickerRootProps$1 as DateTimePickerRootProps, type index$c_DateTimePickerSegment as DateTimePickerSegment, type index$c_DateTimePickerValueProps as DateTimePickerValueProps, type DateTimePickerViewRenderer$1 as DateTimePickerViewRenderer, index$c_Loading as Loading, index$c_Portal as Portal, Root$b as Root, SegmentField as Segment, type SegmentProps$1 as SegmentProps, index$c_TimePanel as TimePanel, type TimePanelProps$1 as TimePanelProps, type TimePanelRenderProps$1 as TimePanelRenderProps, Trigger$2 as Trigger, index$c_Value as Value };
+}
+
+interface HsvaColor {
+    h: number;
+    s: number;
+    v: number;
+    a: number;
+}
+declare function hsvaToHex(hsva: HsvaColor): string;
+interface ColorPickerRootProps extends Omit<React.ComponentPropsWithoutRef<'div'>, 'defaultValue'> {
+    asChild?: boolean;
+    value?: HsvaColor;
+    defaultValue?: HsvaColor;
+    onValueChange?: (v: HsvaColor) => void;
+    disabled?: boolean;
+}
+declare const Root$a: React.ForwardRefExoticComponent<ColorPickerRootProps & React.RefAttributes<HTMLDivElement>>;
+declare const Area$1: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const AreaThumb: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+interface ChannelSliderProps extends React.ComponentPropsWithoutRef<'div'> {
+    channel: 'h' | 'a';
+}
+declare const ChannelSlider: React.ForwardRefExoticComponent<ChannelSliderProps & React.RefAttributes<HTMLDivElement>>;
+declare const Swatch: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+
+declare const index$b_AreaThumb: typeof AreaThumb;
+declare const index$b_ChannelSlider: typeof ChannelSlider;
+type index$b_ColorPickerRootProps = ColorPickerRootProps;
+type index$b_HsvaColor = HsvaColor;
+declare const index$b_Swatch: typeof Swatch;
+declare const index$b_hsvaToHex: typeof hsvaToHex;
+declare namespace index$b {
+  export { Area$1 as Area, index$b_AreaThumb as AreaThumb, index$b_ChannelSlider as ChannelSlider, type index$b_ColorPickerRootProps as ColorPickerRootProps, type index$b_HsvaColor as HsvaColor, Root$a as Root, index$b_Swatch as Swatch, index$b_hsvaToHex as hsvaToHex };
+}
+
+interface FileUploadRootProps extends Omit<React.ComponentPropsWithoutRef<'div'>, 'defaultValue' | 'onError'> {
+    asChild?: boolean;
+    value?: File[];
+    defaultValue?: File[];
+    onValueChange?: (files: File[]) => void;
+    accept?: string;
+    multiple?: boolean;
+    maxSize?: number;
+    maxFiles?: number;
+    disabled?: boolean;
+    onError?: (errors: {
+        file: File;
+        reason: 'size' | 'type' | 'count';
+    }[]) => void;
+}
+declare const Root$9: React.ForwardRefExoticComponent<FileUploadRootProps & React.RefAttributes<HTMLDivElement>>;
+declare const Dropzone: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const Input$3: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>>;
+declare const List: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & React.RefAttributes<HTMLUListElement>>;
+declare const Item$2: React.FC<{
+    file: File;
+    children?: React.ReactNode;
+}>;
+declare const Trigger$1: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const Clear: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+
+declare const index$a_Clear: typeof Clear;
+declare const index$a_Dropzone: typeof Dropzone;
+type index$a_FileUploadRootProps = FileUploadRootProps;
+declare const index$a_List: typeof List;
+declare namespace index$a {
+  export { index$a_Clear as Clear, index$a_Dropzone as Dropzone, type index$a_FileUploadRootProps as FileUploadRootProps, Input$3 as Input, Item$2 as Item, index$a_List as List, Root$9 as Root, Trigger$1 as Trigger };
+}
+
+interface ScrollAreaRootProps extends React.ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+    type?: 'auto' | 'always' | 'scroll' | 'hover';
+    scrollHideDelay?: number;
+}
+declare const Root$8: React.ForwardRefExoticComponent<ScrollAreaRootProps & React.RefAttributes<HTMLDivElement>>;
+declare const Viewport$1: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+interface ScrollbarProps extends React.ComponentPropsWithoutRef<'div'> {
+    orientation?: 'horizontal' | 'vertical';
+    forceMount?: boolean;
+}
+declare const Scrollbar: React.ForwardRefExoticComponent<ScrollbarProps & React.RefAttributes<HTMLDivElement>>;
+declare const Thumb: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const Corner: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+
+declare const index$9_Corner: typeof Corner;
+type index$9_ScrollAreaRootProps = ScrollAreaRootProps;
+declare const index$9_Scrollbar: typeof Scrollbar;
+type index$9_ScrollbarProps = ScrollbarProps;
+declare const index$9_Thumb: typeof Thumb;
+declare namespace index$9 {
+  export { index$9_Corner as Corner, Root$8 as Root, type index$9_ScrollAreaRootProps as ScrollAreaRootProps, index$9_Scrollbar as Scrollbar, type index$9_ScrollbarProps as ScrollbarProps, index$9_Thumb as Thumb, Viewport$1 as Viewport };
+}
+
+interface ToolbarRootProps extends React.ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+    orientation?: 'horizontal' | 'vertical';
+    dir?: 'ltr' | 'rtl';
+    loop?: boolean;
+}
+declare const Root$7: React.ForwardRefExoticComponent<ToolbarRootProps & React.RefAttributes<HTMLDivElement>>;
+declare const Button: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const Link: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, "ref"> & React.RefAttributes<HTMLAnchorElement>>;
+declare const Separator$1: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+
+declare const index$8_Button: typeof Button;
+declare const index$8_Link: typeof Link;
+type index$8_ToolbarRootProps = ToolbarRootProps;
+declare namespace index$8 {
+  export { index$8_Button as Button, index$8_Link as Link, Root$7 as Root, Separator$1 as Separator, type index$8_ToolbarRootProps as ToolbarRootProps };
+}
+
+interface ResizableGroupProps extends React.ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+    direction?: 'horizontal' | 'vertical';
+    onLayout?: (sizes: number[]) => void;
+}
+declare const Group$1: React.ForwardRefExoticComponent<ResizableGroupProps & React.RefAttributes<HTMLDivElement>>;
+interface ResizablePanelProps extends React.ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+    id: string;
+    defaultSize?: number;
+    minSize?: number;
+    maxSize?: number;
+}
+declare const Panel: React.ForwardRefExoticComponent<ResizablePanelProps & React.RefAttributes<HTMLDivElement>>;
+interface ResizableHandleProps extends React.ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+    /** Panel IDs on each side of the handle */
+    between: [string, string];
+}
+declare const Handle: React.ForwardRefExoticComponent<ResizableHandleProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const index$7_Handle: typeof Handle;
+declare const index$7_Panel: typeof Panel;
+type index$7_ResizableGroupProps = ResizableGroupProps;
+type index$7_ResizableHandleProps = ResizableHandleProps;
+type index$7_ResizablePanelProps = ResizablePanelProps;
+declare namespace index$7 {
+  export { Group$1 as Group, index$7_Handle as Handle, index$7_Panel as Panel, type index$7_ResizableGroupProps as ResizableGroupProps, type index$7_ResizableHandleProps as ResizableHandleProps, type index$7_ResizablePanelProps as ResizablePanelProps };
+}
+
+interface CarouselRootProps extends React.ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+    orientation?: 'horizontal' | 'vertical';
+    loop?: boolean;
+    index?: number;
+    defaultIndex?: number;
+    onIndexChange?: (i: number) => void;
+    autoPlayInterval?: number;
+}
+declare const Root$6: React.ForwardRefExoticComponent<CarouselRootProps & React.RefAttributes<HTMLDivElement>>;
+declare const Viewport: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const Container: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const Slide: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const Previous: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const Next: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+
+type index$6_CarouselRootProps = CarouselRootProps;
+declare const index$6_Container: typeof Container;
+declare const index$6_Next: typeof Next;
+declare const index$6_Previous: typeof Previous;
+declare const index$6_Slide: typeof Slide;
+declare const index$6_Viewport: typeof Viewport;
+declare namespace index$6 {
+  export { type index$6_CarouselRootProps as CarouselRootProps, index$6_Container as Container, index$6_Next as Next, index$6_Previous as Previous, Root$6 as Root, index$6_Slide as Slide, index$6_Viewport as Viewport };
+}
+
+interface TreeRootProps extends React.ComponentPropsWithoutRef<'ul'> {
+    asChild?: boolean;
+    defaultExpanded?: string[];
+    expanded?: string[];
+    onExpandedChange?: (expanded: string[]) => void;
+    defaultSelected?: string;
+    selected?: string;
+    onSelectedChange?: (id: string | undefined) => void;
+}
+declare const Root$5: React.ForwardRefExoticComponent<TreeRootProps & React.RefAttributes<HTMLUListElement>>;
+interface TreeItemProps extends React.ComponentPropsWithoutRef<'li'> {
+    asChild?: boolean;
+    id: string;
+    hasChildren?: boolean;
+    level?: number;
+}
+declare const Item$1: React.ForwardRefExoticComponent<TreeItemProps & React.RefAttributes<HTMLLIElement>>;
+declare const Trigger: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const Group: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & React.RefAttributes<HTMLUListElement>>;
+
+declare const index$5_Group: typeof Group;
+type index$5_TreeItemProps = TreeItemProps;
+type index$5_TreeRootProps = TreeRootProps;
+declare const index$5_Trigger: typeof Trigger;
+declare namespace index$5 {
+  export { index$5_Group as Group, Item$1 as Item, Root$5 as Root, type index$5_TreeItemProps as TreeItemProps, type index$5_TreeRootProps as TreeRootProps, index$5_Trigger as Trigger };
+}
+
+interface EditableRootProps extends Omit<React.ComponentPropsWithoutRef<'div'>, 'onSubmit'> {
+    asChild?: boolean;
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (v: string) => void;
+    editing?: boolean;
+    defaultEditing?: boolean;
+    onEditingChange?: (b: boolean) => void;
+    submitMode?: 'enter' | 'blur' | 'both';
+    onSubmit?: (value: string) => void;
+    onCancel?: () => void;
+    disabled?: boolean;
+}
+declare const Root$4: React.ForwardRefExoticComponent<EditableRootProps & React.RefAttributes<HTMLDivElement>>;
+declare const Preview: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+declare const Input$2: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>>;
+
+type index$4_EditableRootProps = EditableRootProps;
+declare const index$4_Preview: typeof Preview;
+declare namespace index$4 {
+  export { type index$4_EditableRootProps as EditableRootProps, Input$2 as Input, index$4_Preview as Preview, Root$4 as Root };
+}
+
+interface TagsInputRootProps extends React.ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+    value?: string[];
+    defaultValue?: string[];
+    onValueChange?: (tags: string[]) => void;
+    delimiters?: string[];
+    maxTags?: number;
+    duplicateTags?: boolean;
+    disabled?: boolean;
+}
+declare const Root$3: React.ForwardRefExoticComponent<TagsInputRootProps & React.RefAttributes<HTMLDivElement>>;
+declare const Input$1: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>>;
+declare const Tag: React.FC<{
+    index: number;
+    children?: React.ReactNode;
+}>;
+declare const Items$1: React.FC<{
+    children: (tag: string, index: number) => React.ReactNode;
+}>;
+
+declare const index$3_Tag: typeof Tag;
+type index$3_TagsInputRootProps = TagsInputRootProps;
+declare namespace index$3 {
+  export { Input$1 as Input, Items$1 as Items, Root$3 as Root, index$3_Tag as Tag, type index$3_TagsInputRootProps as TagsInputRootProps };
+}
+
+interface MentionSuggestion {
+    id: string;
+    label: string;
+}
+interface MentionsRootProps extends React.ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (v: string) => void;
+    triggerChar?: string;
+}
+declare const Root$2: React.ForwardRefExoticComponent<MentionsRootProps & React.RefAttributes<HTMLDivElement>>;
+declare const Textarea$1: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.TextareaHTMLAttributes<HTMLTextAreaElement>, HTMLTextAreaElement>, "ref"> & React.RefAttributes<HTMLTextAreaElement>>;
+interface SuggestionsProps {
+    items: MentionSuggestion[];
+    children?: React.ReactNode;
+    container?: Element | DocumentFragment | null;
+    /** Render inline (no Portal). Use this when the parent is position:relative. */
+    disablePortal?: boolean;
+}
+declare const Suggestions: React.FC<SuggestionsProps>;
+declare const Items: React.FC<{
+    children: (item: MentionSuggestion, index: number, highlighted: boolean) => React.ReactNode;
+}>;
+declare const Item: React.FC<{
+    suggestion: MentionSuggestion;
+    index: number;
+    children?: React.ReactNode;
+}>;
+
+declare const index$2_Item: typeof Item;
+declare const index$2_Items: typeof Items;
+type index$2_MentionSuggestion = MentionSuggestion;
+type index$2_MentionsRootProps = MentionsRootProps;
+declare const index$2_Suggestions: typeof Suggestions;
+type index$2_SuggestionsProps = SuggestionsProps;
+declare namespace index$2 {
+  export { index$2_Item as Item, index$2_Items as Items, type index$2_MentionSuggestion as MentionSuggestion, type index$2_MentionsRootProps as MentionsRootProps, Root$2 as Root, index$2_Suggestions as Suggestions, type index$2_SuggestionsProps as SuggestionsProps, Textarea$1 as Textarea };
+}
+
+interface CardRootProps extends React.ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+}
+interface CardSectionProps extends React.ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+}
+
+declare const Root$1: React.ForwardRefExoticComponent<CardRootProps & React.RefAttributes<HTMLDivElement>>;
+declare const Header: React.ForwardRefExoticComponent<CardSectionProps & React.RefAttributes<HTMLDivElement>>;
+declare const Title: React.ForwardRefExoticComponent<CardSectionProps & React.RefAttributes<HTMLDivElement>>;
+declare const Description: React.ForwardRefExoticComponent<CardSectionProps & React.RefAttributes<HTMLDivElement>>;
+declare const Content: React.ForwardRefExoticComponent<CardSectionProps & React.RefAttributes<HTMLDivElement>>;
+declare const Footer: React.ForwardRefExoticComponent<CardSectionProps & React.RefAttributes<HTMLDivElement>>;
+
+type index$1_CardRootProps = CardRootProps;
+type index$1_CardSectionProps = CardSectionProps;
+declare const index$1_Content: typeof Content;
+declare const index$1_Description: typeof Description;
+declare const index$1_Footer: typeof Footer;
+declare const index$1_Header: typeof Header;
+declare const index$1_Title: typeof Title;
+declare namespace index$1 {
+  export { type index$1_CardRootProps as CardRootProps, type index$1_CardSectionProps as CardSectionProps, index$1_Content as Content, index$1_Description as Description, index$1_Footer as Footer, index$1_Header as Header, Root$1 as Root, index$1_Title as Title };
+}
+
+interface AspectRatioProps$1 extends React.HTMLAttributes<HTMLDivElement> {
+    /** Ratio is width / height, e.g. 16/9 -> 16/9 */
+    ratio?: number;
+}
+declare const AspectRatio: React.ForwardRefExoticComponent<AspectRatioProps$1 & React.RefAttributes<HTMLDivElement>>;
+
+interface AspectRatioProps extends React.ComponentPropsWithoutRef<'div'> {
+    /** The desired ratio (width / height). */
+    ratio?: number;
+    asChild?: boolean;
+}
+
+interface SwitchProps extends Omit<React.ComponentPropsWithoutRef<'button'>, 'value'> {
+    /** Controlled checked state */
+    checked?: boolean;
+    /** Initial checked state (uncontrolled) */
+    defaultChecked?: boolean;
+    /** Called when the checked state changes */
+    onCheckedChange?: (checked: boolean) => void;
+    /** When true, the switch is disabled */
+    disabled?: boolean;
+    /** When true, indicates the switch is required */
+    required?: boolean;
+    /** Form name attribute */
+    name?: string;
+    /** Form value when checked (default: 'on') */
+    value?: string;
+    /** Render as child (Slot pattern) */
+    asChild?: boolean;
+}
+
+declare const Switch: React.ForwardRefExoticComponent<SwitchProps & React.RefAttributes<HTMLButtonElement>>;
+
+interface ToggleProps extends Omit<React.ComponentPropsWithoutRef<'button'>, 'value'> {
+    pressed?: boolean;
+    defaultPressed?: boolean;
+    onPressedChange?: (pressed: boolean) => void;
+    disabled?: boolean;
+    asChild?: boolean;
+}
+declare const Toggle: React.ForwardRefExoticComponent<ToggleProps & React.RefAttributes<HTMLButtonElement>>;
+
+type CheckedState = boolean | 'indeterminate';
+interface CheckboxProps extends Omit<React.ComponentPropsWithoutRef<'button'>, 'value' | 'checked' | 'defaultChecked'> {
+    checked?: CheckedState;
+    defaultChecked?: CheckedState;
+    onCheckedChange?: (checked: CheckedState) => void;
+    disabled?: boolean;
+    required?: boolean;
+    name?: string;
+    value?: string;
+    asChild?: boolean;
+}
+declare const Checkbox: React.ForwardRefExoticComponent<CheckboxProps & React.RefAttributes<HTMLButtonElement>>;
+interface CheckboxIndicatorProps extends React.ComponentPropsWithoutRef<'span'> {
+    asChild?: boolean;
+    forceMount?: boolean;
+    'data-disabled'?: string | boolean;
+}
+declare const CheckboxIndicator: React.ForwardRefExoticComponent<CheckboxIndicatorProps & React.RefAttributes<HTMLSpanElement>>;
+
+interface LabelProps extends React.ComponentPropsWithoutRef<'label'> {
+    asChild?: boolean;
+}
+declare const Label: React.ForwardRefExoticComponent<LabelProps & React.RefAttributes<HTMLLabelElement>>;
+
+type Orientation = 'horizontal' | 'vertical';
+interface SeparatorProps extends React.ComponentPropsWithoutRef<'div'> {
+    orientation?: Orientation;
+    decorative?: boolean;
+    asChild?: boolean;
+}
+declare const Separator: React.ForwardRefExoticComponent<SeparatorProps & React.RefAttributes<HTMLDivElement>>;
+
+interface SkeletonProps extends React.HTMLAttributes<HTMLDivElement> {
+    variant?: 'text' | 'rect' | 'circle';
+}
+declare const Skeleton: React.ForwardRefExoticComponent<SkeletonProps & React.RefAttributes<HTMLDivElement>>;
+
+interface SpinnerProps extends React.HTMLAttributes<HTMLSpanElement> {
+    size?: 'sm' | 'md' | 'lg';
+}
+declare const Spinner: React.ForwardRefExoticComponent<SpinnerProps & React.RefAttributes<HTMLSpanElement>>;
+
+interface BadgeProps extends React.HTMLAttributes<HTMLSpanElement> {
+    variant?: 'default' | 'outline';
+}
+declare const Badge: React.ForwardRefExoticComponent<BadgeProps & React.RefAttributes<HTMLSpanElement>>;
+
+interface AlertProps extends React.HTMLAttributes<HTMLDivElement> {
+    variant?: 'default' | 'success' | 'warning' | 'destructive' | 'info';
+}
+declare const Alert: React.ForwardRefExoticComponent<AlertProps & React.RefAttributes<HTMLDivElement>>;
+
+interface InputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'size'> {
+    value?: string;
+    defaultValue?: string;
+    /** Visual size variant */
+    size?: 'sm' | 'md' | 'lg';
+    /** Marks the input as invalid for ARIA */
+    invalid?: boolean;
+}
+declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>>;
+
+interface TextareaProps extends React.TextareaHTMLAttributes<HTMLTextAreaElement> {
+    value?: string;
+    defaultValue?: string;
+}
+declare const Textarea: React.ForwardRefExoticComponent<TextareaProps & React.RefAttributes<HTMLTextAreaElement>>;
+
+type CurveType = 'linear' | 'catmullRom' | 'step' | 'stepBefore' | 'stepAfter' | 'monotoneX' | 'natural' | 'bumpX';
+type AxisScale = 'linear' | 'log' | 'band';
+type LegendPosition = 'top' | 'bottom' | 'left' | 'right';
+type LabelPosition = 'top' | 'center' | 'inside' | 'outside';
+interface ChartMargin {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+interface ChartDimensions {
+    width: number;
+    height: number;
+    margin: ChartMargin;
+    innerWidth: number;
+    innerHeight: number;
+}
+interface TooltipPayloadEntry {
+    name: string;
+    value: number | string;
+    color: string;
+    dataKey: string;
+}
+interface TooltipState {
+    visible: boolean;
+    x: number;
+    y: number;
+    payload: TooltipPayloadEntry[];
+    label: string;
+}
+interface HighlightScope {
+    /** Which items to highlight on hover */
+    highlight?: 'none' | 'item' | 'series';
+    /** Which items to fade on hover */
+    fade?: 'none' | 'series' | 'global';
+}
+interface ChartRootProps {
+    /** Data array for the chart */
+    data: object[];
+    /** Total width of the SVG (omit for responsive) */
+    width?: number;
+    /** Total height of the SVG */
+    height?: number;
+    /** Outer margins around the plot area */
+    margin?: Partial<ChartMargin>;
+    /** CSS class on the wrapper div */
+    className?: string;
+    /** Accessible label for screen readers */
+    accessibilityLabel?: string;
+    /** Enable colorblind-accessible pattern fills */
+    accessibilityMode?: boolean;
+    children?: React.ReactNode;
+}
+interface ChartPieRootProps {
+    data: object[];
+    width?: number;
+    height?: number;
+    className?: string;
+    accessibilityLabel?: string;
+    children?: React.ReactNode;
+}
+interface ChartRadarRootProps {
+    data: object[];
+    width?: number;
+    height?: number;
+    className?: string;
+    accessibilityLabel?: string;
+    children?: React.ReactNode;
+}
+interface ChartXAxisProps {
+    /** Key in data objects for x values */
+    dataKey?: string;
+    /** Axis label */
+    label?: string;
+    /** Tick count hint */
+    tickCount?: number;
+    /** Custom tick formatter */
+    tickFormatter?: (value: unknown) => string;
+    /** Hide the axis line */
+    hideLine?: boolean;
+    /** Hide ticks */
+    hideTicks?: boolean;
+    /** Scale type */
+    scale?: AxisScale;
+    /** CSS class */
+    className?: string;
+}
+interface ChartYAxisProps {
+    /** Axis label */
+    label?: string;
+    /** Tick count hint */
+    tickCount?: number;
+    /** Custom tick formatter */
+    tickFormatter?: (value: unknown) => string;
+    /** Override domain [min, max] */
+    domain?: [number | 'auto', number | 'auto'];
+    /** Hide the axis line */
+    hideLine?: boolean;
+    /** Hide ticks */
+    hideTicks?: boolean;
+    /** CSS class */
+    className?: string;
+}
+interface ChartGridProps {
+    /** Show horizontal lines */
+    horizontal?: boolean;
+    /** Show vertical lines */
+    vertical?: boolean;
+    /** Stroke color/class override */
+    strokeDasharray?: string;
+    className?: string;
+}
+interface ChartBarProps {
+    /** Key in data for bar values */
+    dataKey: string;
+    /** Bar fill color (falls back to palette) */
+    color?: string;
+    /** Label for legend/tooltip */
+    name?: string;
+    /** Stack group id — bars with same id are stacked */
+    stackId?: string;
+    /** 'vertical' (default) or 'horizontal' */
+    orientation?: 'vertical' | 'horizontal';
+    /** Corner radius */
+    radius?: number;
+    /** Show a label on each bar */
+    showLabel?: boolean;
+    /** Where to place the label relative to the bar */
+    labelPosition?: 'inside' | 'outside' | 'center';
+    /** Custom label text formatter */
+    labelFormatter?: (value: number) => string;
+    /** Highlight scope for hover interactions */
+    highlightScope?: HighlightScope;
+    /** Click handler per bar rect */
+    onClick?: (entry: Record<string, unknown>, index: number) => void;
+    className?: string;
+}
+type MarkShape = 'circle' | 'square' | 'diamond' | 'cross' | 'star' | 'triangle';
+interface ChartLineProps {
+    dataKey: string;
+    color?: string;
+    name?: string;
+    curve?: CurveType;
+    /** Show dots at data points (alias: showDot) */
+    dot?: boolean;
+    /** Alias for dot — use either */
+    showDot?: boolean;
+    /** Dot radius */
+    dotRadius?: number;
+    /** Shape of the mark at each data point */
+    markShape?: MarkShape;
+    /** Connect null/undefined data points by skipping them */
+    connectNulls?: boolean;
+    strokeWidth?: number;
+    strokeDasharray?: string;
+    /** Highlight scope for hover interactions */
+    highlightScope?: HighlightScope;
+    onClick?: (entry: Record<string, unknown>, index: number) => void;
+    className?: string;
+}
+interface ChartAreaProps {
+    dataKey: string;
+    color?: string;
+    name?: string;
+    curve?: CurveType;
+    /** Fill opacity */
+    fillOpacity?: number;
+    /** Stack group id */
+    stackId?: string;
+    strokeWidth?: number;
+    /**
+     * Baseline y value for the area fill.
+     * - number: use yScale(baseline) as the bottom edge
+     * - 'auto': use the chart bottom (innerHeight) — same as default
+     */
+    baseline?: number | 'auto';
+    /** Connect null/undefined data points by skipping them */
+    connectNulls?: boolean;
+    /** Highlight scope for hover interactions */
+    highlightScope?: HighlightScope;
+    /**
+     * If true, use a gradient fill: above-zero uses chart-1 color,
+     * below-zero uses chart-3 color.
+     */
+    fillByValue?: boolean;
+    className?: string;
+}
+type ScatterMarkerShape = 'circle' | 'square' | 'diamond' | 'cross' | 'triangle';
+interface ChartScatterProps {
+    xKey: string;
+    yKey: string;
+    name?: string;
+    color?: string;
+    /** Point radius */
+    radius?: number;
+    /** Shape rendered at each point */
+    markerShape?: ScatterMarkerShape;
+    /** Highlight scope for hover interactions */
+    highlightScope?: HighlightScope;
+    onClick?: (entry: Record<string, unknown>, index: number) => void;
+    className?: string;
+}
+interface ChartBubbleProps extends ChartScatterProps {
+    /** Data key for bubble size */
+    sizeKey: string;
+    /** Min rendered bubble radius */
+    minRadius?: number;
+    /** Max rendered bubble radius */
+    maxRadius?: number;
+}
+interface ChartPieProps {
+    dataKey: string;
+    nameKey?: string;
+    /** Inner radius for donut (0 = pie) */
+    innerRadius?: number;
+    /** Outer radius (default: min(w,h)/2 * 0.8) */
+    outerRadius?: number;
+    /** Gap between slices in degrees */
+    padAngle?: number;
+    /** Corner radius on slices */
+    cornerRadius?: number;
+    /** Colors array override */
+    colors?: string[];
+    /**
+     * Start angle of the arc distribution in degrees.
+     * Default: -90 (top / 12 o'clock).
+     */
+    startAngle?: number;
+    /**
+     * End angle of the arc distribution in degrees.
+     * Default: 270 (full circle clockwise).
+     */
+    endAngle?: number;
+    /**
+     * Label rendered at the midpoint of each arc.
+     * - 'value': raw numeric value
+     * - 'percentage': percentage of total rounded to nearest integer
+     * - function: custom label — receives { name, value, total }
+     */
+    arcLabel?: 'value' | 'percentage' | ((entry: {
+        name: string;
+        value: number;
+        total: number;
+    }) => string);
+    /**
+     * Minimum arc angle (degrees) required before a label is rendered.
+     * Prevents label clutter on very small slices. Default: 5.
+     */
+    arcLabelMinAngle?: number;
+    onClick?: (entry: Record<string, unknown>, index: number) => void;
+    className?: string;
+}
+interface ChartPolarGridProps {
+    /** Number of rings */
+    rings?: number;
+    /**
+     * Ring shape:
+     * - 'sharp' (default): polygon connecting spoke endpoints
+     * - 'circular': concentric circles
+     */
+    shape?: 'circular' | 'sharp';
+    className?: string;
+}
+interface ChartPolarAngleAxisProps {
+    dataKey: string;
+    className?: string;
+}
+interface ChartRadarProps {
+    dataKey: string;
+    color?: string;
+    name?: string;
+    fillOpacity?: number;
+    /** Fill the radar polygon area with semi-transparent color */
+    fillArea?: boolean;
+    /** Show dot marks at each data point (alias: dot) */
+    showMark?: boolean;
+    /** Alias for showMark — use either */
+    dot?: boolean;
+    className?: string;
+}
+interface ChartHeatmapProps {
+    data: object[];
+    xKey: string;
+    yKey: string;
+    valueKey: string;
+    /** Colors from low→high */
+    colorRange?: [string, string];
+    /** Width of the SVG */
+    width?: number;
+    /** Height of the SVG */
+    height?: number;
+    margin?: Partial<ChartMargin>;
+    className?: string;
+    accessibilityLabel?: string;
+}
+interface TreemapNode {
+    name: string;
+    value?: number;
+    children?: TreemapNode[];
+    color?: string;
+}
+interface ChartTreemapProps {
+    data: TreemapNode[];
+    width?: number;
+    height?: number;
+    padding?: number;
+    /** Color palette override */
+    colors?: string[];
+    className?: string;
+    accessibilityLabel?: string;
+    onNodeClick?: (node: TreemapNode) => void;
+}
+interface FunnelEntry {
+    name: string;
+    value: number;
+    color?: string;
+}
+interface ChartFunnelProps {
+    data: FunnelEntry[];
+    width?: number;
+    height?: number;
+    /** Label position */
+    labelPosition?: LabelPosition;
+    /**
+     * Visual variant:
+     * - 'filled' (default): solid fill
+     * - 'outlined': transparent fill with colored stroke
+     */
+    variant?: 'filled' | 'outlined';
+    /**
+     * Edge interpolation:
+     * - 'linear' (default): straight trapezoid edges
+     * - 'linear-sharp': alias for 'linear'
+     * - 'bump': smooth S-curve bezier on each side
+     * - 'step': flat top, vertical drop, flat bottom
+     */
+    curve?: 'linear' | 'linear-sharp' | 'bump' | 'step';
+    /** Pixel gap between sections. Default: 0 */
+    gap?: number;
+    className?: string;
+    accessibilityLabel?: string;
+    onSegmentClick?: (entry: FunnelEntry, index: number) => void;
+}
+interface ChartGaugeProps {
+    value: number;
+    min?: number;
+    max?: number;
+    /** Start angle in degrees (from 12 o'clock, clockwise) */
+    startAngle?: number;
+    /** End angle in degrees */
+    endAngle?: number;
+    /** Arc thickness as fraction of radius */
+    thickness?: number;
+    /** Color stops: [[percentage, color], ...] */
+    colorStops?: [number, string][];
+    /** Show numeric label in center */
+    showLabel?: boolean;
+    /** Custom label render */
+    label?: string | ((value: number, min: number, max: number) => string);
+    width?: number;
+    height?: number;
+    className?: string;
+    accessibilityLabel?: string;
+}
+/** Shared context provided by GaugeContainer to child arc components */
+interface GaugeContextValue {
+    value: number;
+    min: number;
+    max: number;
+    /** Start angle in degrees, clockwise from top */
+    startAngle: number;
+    /** End angle in degrees, clockwise from top */
+    endAngle: number;
+    cx: number;
+    cy: number;
+    outerRadius: number;
+    innerRadius: number;
+    fraction: number;
+}
+/**
+ * Root wrapper for gauge composition.
+ * Provides a shared GaugeContext consumed by GaugeValueArc and GaugeReferenceArc.
+ */
+interface ChartGaugeContainerProps {
+    value: number;
+    min?: number;
+    max?: number;
+    /** Start angle in degrees (clockwise from top / 12 o'clock). Default: -135 */
+    startAngle?: number;
+    /** End angle in degrees. Default: 135 */
+    endAngle?: number;
+    /** SVG width */
+    width?: number;
+    /** SVG height */
+    height?: number;
+    /** Arc thickness in pixels */
+    thickness?: number;
+    className?: string;
+    accessibilityLabel?: string;
+    children?: React.ReactNode;
+}
+/** The colored value arc inside a GaugeContainer */
+interface ChartGaugeValueArcProps {
+    /** Fill color — defaults to chart-1 CSS variable */
+    color?: string;
+    /** Color stops: [[percentage, color], ...] */
+    colorStops?: [number, string][];
+    className?: string;
+}
+/** The gray background track arc inside a GaugeContainer */
+interface ChartGaugeReferenceArcProps {
+    /** Fill color for the background track */
+    color?: string;
+    className?: string;
+}
+interface OhlcEntry {
+    date: string | number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume?: number;
+}
+interface ChartCandlestickProps {
+    data: OhlcEntry[];
+    width?: number;
+    height?: number;
+    margin?: Partial<ChartMargin>;
+    /** Color for bullish candles (close > open) */
+    bullColor?: string;
+    /** Color for bearish candles (close < open) */
+    bearColor?: string;
+    className?: string;
+    accessibilityLabel?: string;
+}
+interface ChartTooltipProps {
+    /** Fully replace the tooltip — receives the current tooltip state */
+    content?: (state: TooltipState) => React.ReactNode;
+    /** Extra class on the tooltip wrapper */
+    className?: string;
+    /** Override background color */
+    background?: string;
+    /** Override border color */
+    border?: string;
+    /** Override border radius in px */
+    borderRadius?: number;
+    /** Override box shadow */
+    boxShadow?: string;
+    /** Override font size in px */
+    fontSize?: number;
+}
+interface ChartLegendEntry {
+    name: string;
+    color: string;
+    dataKey: string;
+}
+interface ChartLegendProps {
+    /** Where to position the legend relative to the chart */
+    position?: LegendPosition;
+    /** Fully replace legend rendering */
+    content?: (entries: ChartLegendEntry[]) => React.ReactNode;
+    /** Render a single entry — wrap each item with custom JSX */
+    renderEntry?: (entry: ChartLegendEntry, index: number) => React.ReactNode;
+    /** Icon shape: 'square' (default) | 'circle' | 'line' */
+    iconType?: 'square' | 'circle' | 'line';
+    /** Icon size in px, default 12 */
+    iconSize?: number;
+    /** Extra class on the legend wrapper */
+    className?: string;
+}
+interface CartesianContextValue {
+    data: Record<string, unknown>[];
+    dimensions: ChartDimensions;
+    xScale: (value: unknown) => number;
+    yScale: (value: number) => number;
+    yDomain: [number, number];
+    xDomain: unknown[];
+    xDataKey: string;
+    isBand: boolean;
+    bandWidth: number;
+    palette: string[];
+    activeIndex: number | null;
+    setActiveIndex: (index: number | null) => void;
+    tooltip: TooltipState;
+    setTooltip: (state: TooltipState) => void;
+    seriesCount: number;
+    registerSeries: (dataKey: string) => number;
+    accessibilityMode: boolean;
+}
+interface PieContextValue {
+    data: Record<string, unknown>[];
+    cx: number;
+    cy: number;
+    palette: string[];
+    tooltip: TooltipState;
+    setTooltip: (state: TooltipState) => void;
+}
+interface RadarContextValue {
+    data: Record<string, unknown>[];
+    cx: number;
+    cy: number;
+    radius: number;
+    angleKeys: string[];
+    palette: string[];
+}
+interface ChartSparkLineProps {
+    /** Array of numeric values */
+    data: number[];
+    /** 'line' or 'bar' sparkline */
+    type?: 'line' | 'bar';
+    /** SVG width */
+    width?: number;
+    /** SVG height */
+    height?: number;
+    /** Stroke / fill color */
+    color?: string;
+    /** Stroke width (line mode only) */
+    strokeWidth?: number;
+    /** Fill area under the line with a semi-transparent color */
+    area?: boolean;
+    /** Show a floating value label on hover (line mode only) */
+    showTooltip?: boolean;
+    /** Highlight the nearest data point with a dot on hover (line mode only) */
+    showHighlight?: boolean;
+    /** Fixed y-axis minimum (overrides auto-computed domain) */
+    yMin?: number;
+    /** Fixed y-axis maximum (overrides auto-computed domain) */
+    yMax?: number;
+    /** CSS class on the SVG element */
+    className?: string;
+}
+interface ChartRangeBarProps {
+    /** Data key for the low value */
+    lowKey: string;
+    /** Data key for the high value */
+    highKey: string;
+    /** Fill color */
+    color?: string;
+    /** Legend / tooltip label */
+    name?: string;
+    /** Corner radius */
+    radius?: number;
+    className?: string;
+}
+interface ChartReferenceLineProps {
+    /** Horizontal reference value (y) */
+    y?: number;
+    /** Vertical reference value (x) */
+    x?: string | number;
+    /** Label text */
+    label?: string;
+    /** Line stroke color */
+    stroke?: string;
+    /** Dash pattern */
+    strokeDasharray?: string;
+    className?: string;
+}
+interface ChartReferenceAreaProps {
+    /** Low y bound */
+    y1?: number;
+    /** High y bound */
+    y2?: number;
+    /** Left x bound */
+    x1?: string | number;
+    /** Right x bound */
+    x2?: string | number;
+    /** Fill color */
+    fill?: string;
+    /** Fill opacity */
+    fillOpacity?: number;
+    className?: string;
+}
+interface ChartRadialBarRootProps {
+    data: object[];
+    width?: number;
+    height?: number;
+    /** Gap between bars in px */
+    gap?: number;
+    className?: string;
+    accessibilityLabel?: string;
+    children?: React.ReactNode;
+}
+interface ChartRadialBarProps {
+    /** Data key for arc length values */
+    dataKey: string;
+    /** Key for slice labels */
+    nameKey?: string;
+    /** Color overrides */
+    colors?: string[];
+    /** Inner radius fraction of min(w,h)/2 */
+    innerRadius?: number;
+    /** Outer radius fraction of min(w,h)/2 */
+    outerRadius?: number;
+    /**
+     * 'vertical' (default): radius encodes value
+     * 'horizontal': angle sweeps encode value
+     */
+    layout?: 'vertical' | 'horizontal';
+    className?: string;
+}
+interface WaterfallEntry {
+    name: string;
+    value: number;
+    color?: string;
+}
+interface ChartWaterfallProps {
+    data: WaterfallEntry[];
+    width?: number;
+    height?: number;
+    margin?: Partial<ChartMargin>;
+    className?: string;
+    accessibilityLabel?: string;
+}
+interface SankeyNode {
+    id: string;
+    color?: string;
+}
+interface SankeyLink {
+    source: string;
+    target: string;
+    value: number;
+}
+interface ChartSankeyProps {
+    nodes: SankeyNode[];
+    links: SankeyLink[];
+    width?: number;
+    height?: number;
+    nodePadding?: number;
+    nodeWidth?: number;
+    /** Node alignment strategy. Default: 'justify' */
+    nodeAlignment?: 'left' | 'right' | 'justify' | 'center';
+    /** Show value labels on links */
+    showLinkValues?: boolean;
+    className?: string;
+    accessibilityLabel?: string;
+}
+interface ChartPyramidProps {
+    data: Array<{
+        name: string;
+        value: number;
+        color?: string;
+    }>;
+    width?: number;
+    height?: number;
+    labelPosition?: LabelPosition;
+    className?: string;
+    accessibilityLabel?: string;
+    onSegmentClick?: (entry: {
+        name: string;
+        value: number;
+        color?: string;
+    }, index: number) => void;
+}
+interface GanttTask {
+    id: string;
+    name: string;
+    start: number;
+    end: number;
+    color?: string;
+    group?: string;
+}
+interface ChartGanttProps {
+    tasks: GanttTask[];
+    width?: number;
+    height?: number;
+    margin?: Partial<ChartMargin>;
+    className?: string;
+    accessibilityLabel?: string;
+}
+interface ChartRadialLineRootProps {
+    data: object[];
+    width?: number;
+    height?: number;
+    className?: string;
+    accessibilityLabel?: string;
+    children?: React.ReactNode;
+}
+interface ChartRadialLineProps {
+    dataKey: string;
+    nameKey?: string;
+    color?: string;
+    curve?: CurveType;
+    closePath?: boolean;
+    area?: boolean;
+    fillOpacity?: number;
+    dot?: boolean;
+    dotRadius?: number;
+    strokeWidth?: number;
+    className?: string;
+}
+interface ChartHistogramProps {
+    data: number[];
+    bins?: number;
+    color?: string;
+    width?: number;
+    height?: number;
+    margin?: Partial<ChartMargin>;
+    showGrid?: boolean;
+    className?: string;
+    accessibilityLabel?: string;
+}
+interface BoxplotEntry {
+    name: string;
+    min: number;
+    q1: number;
+    median: number;
+    q3: number;
+    max: number;
+    color?: string;
+    outliers?: number[];
+}
+interface ChartBoxplotProps {
+    data: BoxplotEntry[];
+    width?: number;
+    height?: number;
+    margin?: Partial<ChartMargin>;
+    orientation?: 'vertical' | 'horizontal';
+    className?: string;
+    accessibilityLabel?: string;
+}
+interface SunburstNode {
+    name: string;
+    value?: number;
+    children?: SunburstNode[];
+    color?: string;
+}
+interface ChartSunburstProps {
+    data: SunburstNode;
+    width?: number;
+    height?: number;
+    innerRadius?: number;
+    className?: string;
+    accessibilityLabel?: string;
+    onNodeClick?: (node: SunburstNode) => void;
+}
+interface ChartChordProps {
+    data: number[][];
+    labels: string[];
+    colors?: string[];
+    width?: number;
+    height?: number;
+    padAngle?: number;
+    className?: string;
+    accessibilityLabel?: string;
+}
+interface ChartRangeAreaProps {
+    lowKey: string;
+    highKey: string;
+    color?: string;
+    name?: string;
+    fillOpacity?: number;
+    curve?: CurveType;
+    className?: string;
+}
+interface ChartLinearGaugeProps {
+    value: number;
+    min?: number;
+    max?: number;
+    width?: number;
+    height?: number;
+    thickness?: number;
+    colorStops?: [number, string][];
+    showLabel?: boolean;
+    label?: string | ((v: number, min: number, max: number) => string);
+    cornerRadius?: number;
+    className?: string;
+    accessibilityLabel?: string;
+}
+interface ChartPieCenterLabelProps {
+    children: React.ReactNode;
+    className?: string;
+}
+interface ChartGaugePointerProps {
+    color?: string;
+    length?: number;
+    width?: number;
+    className?: string;
+}
+
+/**
+ * Root container for cartesian charts (Bar, Line, Area, Scatter, Bubble).
+ * Sets up scales, context, and the SVG viewport.
+ */
+declare const Root: React.ForwardRefExoticComponent<ChartRootProps & React.RefAttributes<HTMLDivElement>>;
+declare const Grid: React.ForwardRefExoticComponent<ChartGridProps & React.RefAttributes<SVGGElement>>;
+declare const XAxis: React.ForwardRefExoticComponent<ChartXAxisProps & React.RefAttributes<SVGGElement>>;
+declare const YAxis: React.ForwardRefExoticComponent<ChartYAxisProps & React.RefAttributes<SVGGElement>>;
+declare const Bar: React.ForwardRefExoticComponent<ChartBarProps & React.RefAttributes<SVGGElement>>;
+declare const Line: React.ForwardRefExoticComponent<ChartLineProps & React.RefAttributes<SVGGElement>>;
+declare const Area: React.ForwardRefExoticComponent<ChartAreaProps & React.RefAttributes<SVGGElement>>;
+declare const Scatter: React.ForwardRefExoticComponent<ChartScatterProps & React.RefAttributes<SVGGElement>>;
+declare const Bubble: React.ForwardRefExoticComponent<ChartBubbleProps & React.RefAttributes<SVGGElement>>;
+declare const Tooltip: React.ForwardRefExoticComponent<ChartTooltipProps & React.RefAttributes<HTMLDivElement>>;
+declare const Legend: React.ForwardRefExoticComponent<ChartLegendProps & React.RefAttributes<HTMLDivElement>>;
+declare const PieRoot: React.ForwardRefExoticComponent<ChartPieRootProps & React.RefAttributes<HTMLDivElement>>;
+declare const Pie: React.ForwardRefExoticComponent<ChartPieProps & React.RefAttributes<SVGGElement>>;
+declare const RadarRoot: React.ForwardRefExoticComponent<ChartRadarRootProps & React.RefAttributes<HTMLDivElement>>;
+declare const PolarGrid: React.ForwardRefExoticComponent<ChartPolarGridProps & React.RefAttributes<SVGGElement>>;
+declare const PolarAngleAxis: React.ForwardRefExoticComponent<ChartPolarAngleAxisProps & React.RefAttributes<SVGGElement>>;
+declare const Radar: React.ForwardRefExoticComponent<ChartRadarProps & React.RefAttributes<SVGGElement>>;
+declare const Heatmap: React.ForwardRefExoticComponent<ChartHeatmapProps & React.RefAttributes<HTMLDivElement>>;
+declare const Treemap: React.ForwardRefExoticComponent<ChartTreemapProps & React.RefAttributes<HTMLDivElement>>;
+declare const Funnel: React.ForwardRefExoticComponent<ChartFunnelProps & React.RefAttributes<HTMLDivElement>>;
+declare const Gauge: React.ForwardRefExoticComponent<ChartGaugeProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Headless gauge wrapper that provides a GaugeContext to child arc components.
+ * Renders an SVG centered with the given width/height.
+ */
+declare const GaugeContainer: React.ForwardRefExoticComponent<ChartGaugeContainerProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * The colored value arc inside a GaugeContainer.
+ * Reads value/angle context from GaugeContainer.
+ */
+declare const GaugeValueArc: React.ForwardRefExoticComponent<ChartGaugeValueArcProps & React.RefAttributes<SVGPathElement>>;
+/**
+ * The gray background track arc inside a GaugeContainer.
+ */
+declare const GaugeReferenceArc: React.ForwardRefExoticComponent<ChartGaugeReferenceArcProps & React.RefAttributes<SVGPathElement>>;
+declare const CandlestickChart: React.ForwardRefExoticComponent<ChartCandlestickProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Compact inline sparkline chart (no axes, no tooltip).
+ * Renders a tiny SVG line or bar chart from a plain number array.
+ */
+declare const SparkLine: React.ForwardRefExoticComponent<ChartSparkLineProps & React.RefAttributes<SVGSVGElement>>;
+/**
+ * Floating bar series — renders bars from yScale(low) to yScale(high).
+ * Must be used inside Chart.Root.
+ */
+declare const RangeBar: React.ForwardRefExoticComponent<ChartRangeBarProps & React.RefAttributes<SVGGElement>>;
+/**
+ * Horizontal or vertical reference line drawn across the plot area.
+ * Must be used inside Chart.Root.
+ */
+declare const ReferenceLine: React.ForwardRefExoticComponent<ChartReferenceLineProps & React.RefAttributes<SVGGElement>>;
+/**
+ * Shaded rectangular region drawn on the plot area.
+ * Must be used inside Chart.Root.
+ */
+declare const ReferenceArea: React.ForwardRefExoticComponent<ChartReferenceAreaProps & React.RefAttributes<SVGGElement>>;
+/**
+ * Root container for radial bar (polar bar) charts.
+ */
+declare const RadialBarRoot: React.ForwardRefExoticComponent<ChartRadialBarRootProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Radial bar series — each data row gets one arc at a different radius level.
+ * Must be used inside Chart.RadialBarRoot.
+ */
+declare const RadialBar: React.ForwardRefExoticComponent<ChartRadialBarProps & React.RefAttributes<SVGGElement>>;
+/**
+ * Waterfall chart — bars start where the previous bar ended.
+ * Positive values go up, negative go down. Connector lines link bars.
+ */
+declare const Waterfall: React.ForwardRefExoticComponent<ChartWaterfallProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Basic Sankey diagram — nodes + bezier curved links proportional to value.
+ */
+declare const Sankey: React.ForwardRefExoticComponent<ChartSankeyProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Pyramid chart — like Funnel but widest at bottom (rows reversed).
+ * Shares the same funnel layout algorithm with reversed data order.
+ */
+declare const Pyramid: React.ForwardRefExoticComponent<ChartPyramidProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Gantt chart — horizontal bars on a numeric time axis.
+ * Each task gets its own row.
+ */
+declare const Gantt: React.ForwardRefExoticComponent<ChartGanttProps & React.RefAttributes<HTMLDivElement>>;
+declare const RadialLineRoot: React.ForwardRefExoticComponent<ChartRadialLineRootProps & React.RefAttributes<HTMLDivElement>>;
+declare const RadialLine: React.ForwardRefExoticComponent<ChartRadialLineProps & React.RefAttributes<SVGGElement>>;
+declare const Histogram: React.ForwardRefExoticComponent<ChartHistogramProps & React.RefAttributes<HTMLDivElement>>;
+declare const Boxplot: React.ForwardRefExoticComponent<ChartBoxplotProps & React.RefAttributes<HTMLDivElement>>;
+declare const Sunburst: React.ForwardRefExoticComponent<ChartSunburstProps & React.RefAttributes<HTMLDivElement>>;
+declare const Chord: React.ForwardRefExoticComponent<ChartChordProps & React.RefAttributes<HTMLDivElement>>;
+declare const RangeArea: React.ForwardRefExoticComponent<ChartRangeAreaProps & React.RefAttributes<SVGGElement>>;
+declare const LinearGauge: React.ForwardRefExoticComponent<ChartLinearGaugeProps & React.RefAttributes<HTMLDivElement>>;
+declare const PieCenterLabel: React.ForwardRefExoticComponent<ChartPieCenterLabelProps & React.RefAttributes<SVGGElement>>;
+declare const GaugePointer: React.ForwardRefExoticComponent<ChartGaugePointerProps & React.RefAttributes<SVGGElement>>;
+
+/**
+ * Minimal scale implementations — no d3 dependency.
+ * Each scale maps a domain value to a range pixel value.
+ */
+/**
+ * Maps a continuous numeric domain to a continuous numeric range.
+ */
+declare function linearScale(domain: [number, number], range: [number, number]): (value: number) => number;
+/**
+ * Logarithmic (base-10) scale. Domain must be > 0.
+ */
+declare function logScale(domain: [number, number], range: [number, number]): (value: number) => number;
+interface BandScale {
+    /** Maps a domain value to the start pixel of its band */
+    scale: (value: string) => number;
+    /** The width of each band (after inner padding) */
+    bandwidth: number;
+    /** The step size from one band start to the next */
+    step: number;
+}
+/**
+ * Divides a range evenly among discrete domain values with optional padding.
+ *
+ * @param domain     Ordered list of category strings
+ * @param range      [start, end] pixel range
+ * @param paddingInner  Gap between bands as a fraction of step (0–1)
+ * @param paddingOuter  Gap at range edges as a fraction of step (0–1)
+ */
+declare function bandScale(domain: string[], range: [number, number], paddingInner?: number, paddingOuter?: number): BandScale;
+/**
+ * Maps domain strings to range values (usually colors) by cycling.
+ */
+declare function ordinalScale(domain: string[], range: string[]): (value: string) => string;
+/**
+ * Generate "nice" linear tick values spanning [min, max].
+ * Returns approximately `count` ticks on round numbers.
+ */
+declare function niceLinearTicks(min: number, max: number, count?: number): number[];
+/**
+ * Round a domain extent to nice bounds for display.
+ */
+declare function niceDomain(min: number, max: number, count?: number): [number, number];
+/**
+ * Returns [min, max] of a numeric array.
+ */
+declare function extent(values: number[]): [number, number];
+/**
+ * Computes y-domain from a data array using multiple data keys.
+ * If any series has a stackId, domains are summed per index.
+ */
+declare function computeYDomain(data: Record<string, unknown>[], dataKeys: string[], stackIds: (string | undefined)[], includeZero?: boolean): [number, number];
+
+/**
+ * SVG path string generators — no external dependencies.
+ */
+
+type Point = [number, number];
+/**
+ * Build an SVG path `d` string from an array of [x, y] points.
+ * Supports linear, catmullRom, step, stepBefore, and stepAfter interpolation.
+ */
+declare function buildLinePath(points: Point[], curve?: CurveType): string;
+/**
+ * Build a closed SVG path for an area chart.
+ * @param topPoints  Upper edge [[x,y], ...]
+ * @param bottomPoints  Lower edge — same length as topPoints. For non-stacked
+ *                      areas, provide a constant y0 value via `buildAreaPathFlat`.
+ * @param curve      Curve interpolation applied to the top edge
+ */
+declare function buildAreaPath(topPoints: Point[], bottomPoints: Point[], curve?: CurveType): string;
+/**
+ * Simpler area path where all bottom points share one y0 value.
+ */
+declare function buildAreaPathFlat(topPoints: Point[], y0: number, curve?: CurveType): string;
+/**
+ * Build an SVG arc path for a pie/donut slice.
+ * Angles are in radians, measured clockwise from the top (12 o'clock).
+ */
+declare function buildArcPath(cx: number, cy: number, outerRadius: number, innerRadius: number, startAngle: number, endAngle: number, cornerRadius?: number): string;
+/**
+ * Build a closed polygon SVG path for a radar chart series.
+ * @param values   Normalised values in [0, 1] for each axis
+ * @param cx       Center x
+ * @param cy       Center y
+ * @param radius   Max radius
+ */
+declare function buildRadarPath(values: number[], cx: number, cy: number, radius: number): string;
+/**
+ * Returns SVG rect props for a bar with optional rounded top corners.
+ */
+interface BarRectProps {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rx: number;
+    ry: number;
+}
+declare function buildBarRect(x: number, y: number, width: number, height: number, radius?: number, _orientation?: 'vertical' | 'horizontal'): BarRectProps;
+declare function fmt(n: number): string;
+
+/**
+ * Layout algorithms: Squarified Treemap, Funnel layout.
+ * No external dependencies.
+ */
+interface TreemapLayoutNode {
+    name: string;
+    value: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    depth: number;
+    color?: string;
+    children?: TreemapLayoutNode[];
+}
+interface RawNode {
+    name: string;
+    value?: number;
+    children?: RawNode[];
+    color?: string;
+}
+/**
+ * Compute a squarified treemap layout.
+ * Returns a flat list of leaf nodes with computed x/y/width/height.
+ */
+declare function squarifyTreemap(nodes: RawNode[], x: number, y: number, width: number, height: number, padding?: number, depth?: number): TreemapLayoutNode[];
+interface FunnelLayoutSegment {
+    name: string;
+    value: number;
+    color?: string;
+    /** Trapezoid top-left x */
+    x1: number;
+    /** Trapezoid top-right x */
+    x2: number;
+    /** Trapezoid bottom-left x */
+    x3: number;
+    /** Trapezoid bottom-right x */
+    x4: number;
+    /** Top y */
+    y1: number;
+    /** Bottom y */
+    y2: number;
+    /** SVG path string */
+    path: string;
+    /** Percentage of first item */
+    percentage: number;
+}
+/**
+ * Compute funnel trapezoid positions.
+ * Each segment is a trapezoid that narrows from top to bottom proportionally.
+ */
+declare function computeFunnelLayout(data: Array<{
+    name: string;
+    value: number;
+    color?: string;
+}>, x: number, y: number, width: number, height: number, gap?: number): FunnelLayoutSegment[];
+interface GaugeArcData {
+    /** Background (track) arc path */
+    trackPath: string;
+    /** Filled arc path */
+    fillPath: string;
+    /** Center x */
+    cx: number;
+    /** Center y */
+    cy: number;
+    /** Outer radius */
+    outerRadius: number;
+    /** Inner radius */
+    innerRadius: number;
+    /** Normalised value [0, 1] */
+    fraction: number;
+}
+/**
+ * Compute paths for an arc-style gauge.
+ * Angles use SVG convention: measured clockwise from top (12 o'clock).
+ *
+ * @param value         Current value
+ * @param min           Minimum value
+ * @param max           Maximum value
+ * @param startDeg      Start angle in degrees (clockwise from top)
+ * @param endDeg        End angle in degrees
+ * @param outerRadius   Outer edge radius
+ * @param thickness     Arc thickness (pixels)
+ */
+declare function computeGaugeArcs(value: number, min: number, max: number, startDeg: number, endDeg: number, outerRadius: number, thickness: number): GaugeArcData;
+interface CandlestickBar {
+    x: number;
+    candleWidth: number;
+    openY: number;
+    closeY: number;
+    highY: number;
+    lowY: number;
+    bullish: boolean;
+}
+/**
+ * Compute candlestick bar positions from OHLC data.
+ */
+declare function computeCandlestickBars(data: Array<{
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+}>, xScale: (index: number) => number, yScale: (value: number) => number, bandWidth: number): CandlestickBar[];
+interface HeatmapCell {
+    xValue: string;
+    yValue: string;
+    value: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    normalised: number;
+}
+/**
+ * Compute heatmap cell positions.
+ */
+declare function computeHeatmapCells(data: Record<string, unknown>[], xKey: string, yKey: string, valueKey: string, xScale: (v: string) => number, yScale: (v: string) => number, cellWidth: number, cellHeight: number): HeatmapCell[];
+
+/**
+ * @structyl/primitives — Chart
+ *
+ * Headless SVG chart primitives. No external chart library dependencies.
+ * Provides all layout algorithms, scale functions, and path generators.
+ */
+
+declare const index_Area: typeof Area;
+type index_AxisScale = AxisScale;
+declare const index_Bar: typeof Bar;
+type index_BarRectProps = BarRectProps;
+declare const index_Boxplot: typeof Boxplot;
+type index_BoxplotEntry = BoxplotEntry;
+declare const index_Bubble: typeof Bubble;
+type index_CandlestickBar = CandlestickBar;
+type index_CartesianContextValue = CartesianContextValue;
+type index_ChartAreaProps = ChartAreaProps;
+type index_ChartBarProps = ChartBarProps;
+type index_ChartBoxplotProps = ChartBoxplotProps;
+type index_ChartBubbleProps = ChartBubbleProps;
+type index_ChartCandlestickProps = ChartCandlestickProps;
+type index_ChartChordProps = ChartChordProps;
+type index_ChartDimensions = ChartDimensions;
+type index_ChartFunnelProps = ChartFunnelProps;
+type index_ChartGanttProps = ChartGanttProps;
+type index_ChartGaugeContainerProps = ChartGaugeContainerProps;
+type index_ChartGaugePointerProps = ChartGaugePointerProps;
+type index_ChartGaugeProps = ChartGaugeProps;
+type index_ChartGaugeReferenceArcProps = ChartGaugeReferenceArcProps;
+type index_ChartGaugeValueArcProps = ChartGaugeValueArcProps;
+type index_ChartGridProps = ChartGridProps;
+type index_ChartHeatmapProps = ChartHeatmapProps;
+type index_ChartHistogramProps = ChartHistogramProps;
+type index_ChartLegendProps = ChartLegendProps;
+type index_ChartLineProps = ChartLineProps;
+type index_ChartLinearGaugeProps = ChartLinearGaugeProps;
+type index_ChartMargin = ChartMargin;
+type index_ChartPieCenterLabelProps = ChartPieCenterLabelProps;
+type index_ChartPieProps = ChartPieProps;
+type index_ChartPieRootProps = ChartPieRootProps;
+type index_ChartPolarAngleAxisProps = ChartPolarAngleAxisProps;
+type index_ChartPolarGridProps = ChartPolarGridProps;
+type index_ChartPyramidProps = ChartPyramidProps;
+type index_ChartRadarProps = ChartRadarProps;
+type index_ChartRadarRootProps = ChartRadarRootProps;
+type index_ChartRadialBarProps = ChartRadialBarProps;
+type index_ChartRadialBarRootProps = ChartRadialBarRootProps;
+type index_ChartRadialLineProps = ChartRadialLineProps;
+type index_ChartRadialLineRootProps = ChartRadialLineRootProps;
+type index_ChartRangeAreaProps = ChartRangeAreaProps;
+type index_ChartRangeBarProps = ChartRangeBarProps;
+type index_ChartReferenceAreaProps = ChartReferenceAreaProps;
+type index_ChartReferenceLineProps = ChartReferenceLineProps;
+type index_ChartRootProps = ChartRootProps;
+type index_ChartSankeyProps = ChartSankeyProps;
+type index_ChartScatterProps = ChartScatterProps;
+type index_ChartSparkLineProps = ChartSparkLineProps;
+type index_ChartSunburstProps = ChartSunburstProps;
+type index_ChartTooltipProps = ChartTooltipProps;
+type index_ChartTreemapProps = ChartTreemapProps;
+type index_ChartWaterfallProps = ChartWaterfallProps;
+type index_ChartXAxisProps = ChartXAxisProps;
+type index_ChartYAxisProps = ChartYAxisProps;
+declare const index_Chord: typeof Chord;
+type index_CurveType = CurveType;
+declare const index_Funnel: typeof Funnel;
+type index_FunnelEntry = FunnelEntry;
+type index_FunnelLayoutSegment = FunnelLayoutSegment;
+declare const index_Gantt: typeof Gantt;
+type index_GanttTask = GanttTask;
+declare const index_Gauge: typeof Gauge;
+type index_GaugeArcData = GaugeArcData;
+declare const index_GaugeContainer: typeof GaugeContainer;
+type index_GaugeContextValue = GaugeContextValue;
+declare const index_GaugePointer: typeof GaugePointer;
+declare const index_GaugeReferenceArc: typeof GaugeReferenceArc;
+declare const index_GaugeValueArc: typeof GaugeValueArc;
+declare const index_Grid: typeof Grid;
+declare const index_Heatmap: typeof Heatmap;
+type index_HeatmapCell = HeatmapCell;
+type index_HighlightScope = HighlightScope;
+declare const index_Histogram: typeof Histogram;
+type index_LabelPosition = LabelPosition;
+declare const index_Legend: typeof Legend;
+type index_LegendPosition = LegendPosition;
+declare const index_Line: typeof Line;
+declare const index_LinearGauge: typeof LinearGauge;
+type index_MarkShape = MarkShape;
+type index_OhlcEntry = OhlcEntry;
+declare const index_Pie: typeof Pie;
+declare const index_PieCenterLabel: typeof PieCenterLabel;
+type index_PieContextValue = PieContextValue;
+declare const index_PieRoot: typeof PieRoot;
+declare const index_PolarAngleAxis: typeof PolarAngleAxis;
+declare const index_PolarGrid: typeof PolarGrid;
+declare const index_Pyramid: typeof Pyramid;
+declare const index_Radar: typeof Radar;
+type index_RadarContextValue = RadarContextValue;
+declare const index_RadarRoot: typeof RadarRoot;
+declare const index_RadialBar: typeof RadialBar;
+declare const index_RadialBarRoot: typeof RadialBarRoot;
+declare const index_RadialLine: typeof RadialLine;
+declare const index_RadialLineRoot: typeof RadialLineRoot;
+declare const index_RangeArea: typeof RangeArea;
+declare const index_RangeBar: typeof RangeBar;
+declare const index_ReferenceArea: typeof ReferenceArea;
+declare const index_ReferenceLine: typeof ReferenceLine;
+declare const index_Root: typeof Root;
+declare const index_Sankey: typeof Sankey;
+type index_SankeyLink = SankeyLink;
+type index_SankeyNode = SankeyNode;
+declare const index_Scatter: typeof Scatter;
+type index_ScatterMarkerShape = ScatterMarkerShape;
+declare const index_SparkLine: typeof SparkLine;
+declare const index_Sunburst: typeof Sunburst;
+type index_SunburstNode = SunburstNode;
+declare const index_Tooltip: typeof Tooltip;
+type index_TooltipPayloadEntry = TooltipPayloadEntry;
+type index_TooltipState = TooltipState;
+declare const index_Treemap: typeof Treemap;
+type index_TreemapLayoutNode = TreemapLayoutNode;
+type index_TreemapNode = TreemapNode;
+declare const index_Waterfall: typeof Waterfall;
+type index_WaterfallEntry = WaterfallEntry;
+declare const index_XAxis: typeof XAxis;
+declare const index_YAxis: typeof YAxis;
+declare const index_bandScale: typeof bandScale;
+declare const index_buildArcPath: typeof buildArcPath;
+declare const index_buildAreaPath: typeof buildAreaPath;
+declare const index_buildAreaPathFlat: typeof buildAreaPathFlat;
+declare const index_buildBarRect: typeof buildBarRect;
+declare const index_buildLinePath: typeof buildLinePath;
+declare const index_buildRadarPath: typeof buildRadarPath;
+declare const index_computeCandlestickBars: typeof computeCandlestickBars;
+declare const index_computeFunnelLayout: typeof computeFunnelLayout;
+declare const index_computeGaugeArcs: typeof computeGaugeArcs;
+declare const index_computeHeatmapCells: typeof computeHeatmapCells;
+declare const index_computeYDomain: typeof computeYDomain;
+declare const index_extent: typeof extent;
+declare const index_fmt: typeof fmt;
+declare const index_linearScale: typeof linearScale;
+declare const index_logScale: typeof logScale;
+declare const index_niceDomain: typeof niceDomain;
+declare const index_niceLinearTicks: typeof niceLinearTicks;
+declare const index_ordinalScale: typeof ordinalScale;
+declare const index_squarifyTreemap: typeof squarifyTreemap;
+declare namespace index {
+  export { index_Area as Area, type index_AxisScale as AxisScale, index_Bar as Bar, type index_BarRectProps as BarRectProps, index_Boxplot as Boxplot, type index_BoxplotEntry as BoxplotEntry, index_Bubble as Bubble, CandlestickChart as Candlestick, type index_CandlestickBar as CandlestickBar, type index_CartesianContextValue as CartesianContextValue, type index_ChartAreaProps as ChartAreaProps, type index_ChartBarProps as ChartBarProps, type index_ChartBoxplotProps as ChartBoxplotProps, type index_ChartBubbleProps as ChartBubbleProps, type index_ChartCandlestickProps as ChartCandlestickProps, type index_ChartChordProps as ChartChordProps, type index_ChartDimensions as ChartDimensions, type index_ChartFunnelProps as ChartFunnelProps, type index_ChartGanttProps as ChartGanttProps, type index_ChartGaugeContainerProps as ChartGaugeContainerProps, type index_ChartGaugePointerProps as ChartGaugePointerProps, type index_ChartGaugeProps as ChartGaugeProps, type index_ChartGaugeReferenceArcProps as ChartGaugeReferenceArcProps, type index_ChartGaugeValueArcProps as ChartGaugeValueArcProps, type index_ChartGridProps as ChartGridProps, type index_ChartHeatmapProps as ChartHeatmapProps, type index_ChartHistogramProps as ChartHistogramProps, type index_ChartLegendProps as ChartLegendProps, type index_ChartLineProps as ChartLineProps, type index_ChartLinearGaugeProps as ChartLinearGaugeProps, type index_ChartMargin as ChartMargin, type index_ChartPieCenterLabelProps as ChartPieCenterLabelProps, type index_ChartPieProps as ChartPieProps, type index_ChartPieRootProps as ChartPieRootProps, type index_ChartPolarAngleAxisProps as ChartPolarAngleAxisProps, type index_ChartPolarGridProps as ChartPolarGridProps, type index_ChartPyramidProps as ChartPyramidProps, type index_ChartRadarProps as ChartRadarProps, type index_ChartRadarRootProps as ChartRadarRootProps, type index_ChartRadialBarProps as ChartRadialBarProps, type index_ChartRadialBarRootProps as ChartRadialBarRootProps, type index_ChartRadialLineProps as ChartRadialLineProps, type index_ChartRadialLineRootProps as ChartRadialLineRootProps, type index_ChartRangeAreaProps as ChartRangeAreaProps, type index_ChartRangeBarProps as ChartRangeBarProps, type index_ChartReferenceAreaProps as ChartReferenceAreaProps, type index_ChartReferenceLineProps as ChartReferenceLineProps, type index_ChartRootProps as ChartRootProps, type index_ChartSankeyProps as ChartSankeyProps, type index_ChartScatterProps as ChartScatterProps, type index_ChartSparkLineProps as ChartSparkLineProps, type index_ChartSunburstProps as ChartSunburstProps, type index_ChartTooltipProps as ChartTooltipProps, type index_ChartTreemapProps as ChartTreemapProps, type index_ChartWaterfallProps as ChartWaterfallProps, type index_ChartXAxisProps as ChartXAxisProps, type index_ChartYAxisProps as ChartYAxisProps, index_Chord as Chord, type index_CurveType as CurveType, index_Funnel as Funnel, type index_FunnelEntry as FunnelEntry, type index_FunnelLayoutSegment as FunnelLayoutSegment, index_Gantt as Gantt, type index_GanttTask as GanttTask, index_Gauge as Gauge, type index_GaugeArcData as GaugeArcData, index_GaugeContainer as GaugeContainer, type index_GaugeContextValue as GaugeContextValue, index_GaugePointer as GaugePointer, index_GaugeReferenceArc as GaugeReferenceArc, index_GaugeValueArc as GaugeValueArc, index_Grid as Grid, index_Heatmap as Heatmap, type index_HeatmapCell as HeatmapCell, type index_HighlightScope as HighlightScope, index_Histogram as Histogram, type index_LabelPosition as LabelPosition, index_Legend as Legend, type index_LegendPosition as LegendPosition, index_Line as Line, index_LinearGauge as LinearGauge, type index_MarkShape as MarkShape, type index_OhlcEntry as OhlcEntry, index_Pie as Pie, index_PieCenterLabel as PieCenterLabel, type index_PieContextValue as PieContextValue, index_PieRoot as PieRoot, index_PolarAngleAxis as PolarAngleAxis, index_PolarGrid as PolarGrid, index_Pyramid as Pyramid, index_Radar as Radar, type index_RadarContextValue as RadarContextValue, index_RadarRoot as RadarRoot, index_RadialBar as RadialBar, index_RadialBarRoot as RadialBarRoot, index_RadialLine as RadialLine, index_RadialLineRoot as RadialLineRoot, index_RangeArea as RangeArea, index_RangeBar as RangeBar, index_ReferenceArea as ReferenceArea, index_ReferenceLine as ReferenceLine, index_Root as Root, index_Sankey as Sankey, type index_SankeyLink as SankeyLink, type index_SankeyNode as SankeyNode, index_Scatter as Scatter, type index_ScatterMarkerShape as ScatterMarkerShape, index_SparkLine as SparkLine, index_Sunburst as Sunburst, type index_SunburstNode as SunburstNode, index_Tooltip as Tooltip, type index_TooltipPayloadEntry as TooltipPayloadEntry, type index_TooltipState as TooltipState, index_Treemap as Treemap, type index_TreemapLayoutNode as TreemapLayoutNode, type index_TreemapNode as TreemapNode, index_Waterfall as Waterfall, type index_WaterfallEntry as WaterfallEntry, index_XAxis as XAxis, index_YAxis as YAxis, index_bandScale as bandScale, index_buildArcPath as buildArcPath, index_buildAreaPath as buildAreaPath, index_buildAreaPathFlat as buildAreaPathFlat, index_buildBarRect as buildBarRect, index_buildLinePath as buildLinePath, index_buildRadarPath as buildRadarPath, index_computeCandlestickBars as computeCandlestickBars, index_computeFunnelLayout as computeFunnelLayout, index_computeGaugeArcs as computeGaugeArcs, index_computeHeatmapCells as computeHeatmapCells, index_computeYDomain as computeYDomain, index_extent as extent, index_fmt as fmt, index_linearScale as linearScale, index_logScale as logScale, index_niceDomain as niceDomain, index_niceLinearTicks as niceLinearTicks, index_ordinalScale as ordinalScale, index_squarifyTreemap as squarifyTreemap };
+}
+
+export { index$D as Accordion, type AccordionContentProps, type AccordionHeaderProps, type AccordionItemProps, type AccordionMultipleProps, type AccordionRootProps, type AccordionSingleProps, type AccordionTriggerProps, Alert, index$B as AlertDialog, type AlertDialogActionProps, type AlertDialogCancelProps, type AlertDialogContentProps, type AlertDialogDescriptionProps, type AlertDialogOverlayProps, type AlertDialogPortalProps, type AlertDialogRootProps, type AlertDialogTitleProps, type AlertDialogTriggerProps, type AlertProps, AspectRatio, type AspectRatioProps, index$K as Avatar, type AvatarFallbackProps, type AvatarImageProps, type AvatarRootProps, type AxisScale, Badge, type BadgeProps, type BarRectProps, type BoxplotEntry, index$r as Breadcrumb, type BreadcrumbProps, Button$1 as Button, type ButtonProps$1 as ButtonProps, index$g as Calendar, type CalendarDateRange, type CalendarRootProps, type CandlestickBar, index$1 as Card, type CardRootProps, type CardSectionProps, index$6 as Carousel, type CarouselRootProps, type CartesianContextValue, index as Chart, type ChartAreaProps, type ChartBarProps, type ChartBoxplotProps, type ChartBubbleProps, type ChartCandlestickProps, type ChartChordProps, type ChartDimensions, type ChartFunnelProps, type ChartGanttProps, type ChartGaugeContainerProps, type ChartGaugePointerProps, type ChartGaugeProps, type ChartGaugeReferenceArcProps, type ChartGaugeValueArcProps, type ChartGridProps, type ChartHeatmapProps, type ChartHistogramProps, type ChartLegendEntry, type ChartLegendProps, type ChartLineProps, type ChartLinearGaugeProps, type ChartMargin, type ChartPieCenterLabelProps, type ChartPieProps, type ChartPieRootProps, type ChartPolarAngleAxisProps, type ChartPolarGridProps, type ChartPyramidProps, type ChartRadarProps, type ChartRadarRootProps, type ChartRadialBarProps, type ChartRadialBarRootProps, type ChartRadialLineProps, type ChartRadialLineRootProps, type ChartRangeAreaProps, type ChartRangeBarProps, type ChartReferenceAreaProps, type ChartReferenceLineProps, type ChartRootProps, type ChartSankeyProps, type ChartScatterProps, type ChartSparkLineProps, type ChartSunburstProps, type ChartTooltipProps, type ChartTreemapProps, type ChartWaterfallProps, type ChartXAxisProps, type ChartYAxisProps, Checkbox, CheckboxIndicator, type CheckboxProps, type CheckedState, index$E as Collapsible, type CollapsibleContentProps, type CollapsibleRootProps, type CollapsibleTriggerProps, index$b as ColorPicker, type ColorPickerRootProps, index$m as Combobox, type ComboboxContentProps, type ComboboxInputProps, type ComboboxItemProps, type ComboboxPortalProps, type ComboboxRootProps, index$k as Command, type CommandGroupProps, type CommandInputProps, type CommandItemProps, type CommandRootProps, index$u as ContextMenu, type ContextMenuRootProps, type ContextMenuTriggerProps, type CurveType, type CustomMatcher, DEFAULT_MAX_DATE, DEFAULT_MIN_DATE, index$f as DatePicker, type DatePickerFormat, type DatePickerRootProps, type DatePickerValueProps, type DatePickerView, type DatePickerViewRenderer, type DateRange, index$d as DateRangePicker, type DateRangePickerFormat, type DateRangePickerRootProps, type DateRangePickerShortcut, type DateRangePickerShortcutsProps, type DateRangePickerValueProps, type DateRangePickerViewRenderer, type DateRangePosition, type DateRangeTuple, type DateRangeValidationError, type DateRangeValue, index$c as DateTimePicker, type DateTimePickerFormat, type DateTimePickerRootProps, type DateTimePickerSegment, type SegmentProps as DateTimePickerSegmentProps, type TimePanelProps as DateTimePickerTimePanelProps, type TimePanelRenderProps as DateTimePickerTimePanelRenderProps, type DateTimePickerValueProps, type DateTimePickerView, type DateTimePickerViewRenderer, type DateTimeValidationError, type DateTimeValidationOptions, type DateValidationError, type DateValidationOptions, index$L as Dialog, type DialogCloseProps, type DialogContentProps, type DialogDescriptionProps, type DialogOverlayProps, type DialogPortalProps, type DialogRootProps, type DialogTitleProps, type DialogTriggerProps, index$v as DropdownMenu, type DropdownMenuRootProps, type DropdownMenuTriggerProps, index$4 as Editable, type EditableRootProps, index$a as FileUpload, type FileUploadRootProps, index$F as Form, type FormControlProps, type FormFieldProps, type FormLabelProps, type FormMessageProps, type FormProps, type FormSubmitProps, type FormValidityStateProps, type FunnelEntry, type FunnelLayoutSegment, type GanttTask, type GaugeArcData, type GaugeContextValue, type HeatmapCell, type HighlightScope, index$y as HoverCard, type HoverCardArrowProps, type HoverCardContentProps, type HoverCardPortalProps, type HoverCardRootProps, type HoverCardTriggerProps, type HsvaColor, type ImageLoadingStatus, Input, type InputProps, Label, type LabelPosition, type LabelProps, type LegendPosition, type MarkShape, type Matcher, type MentionSuggestion, index$2 as Mentions, type MentionsRootProps, type SuggestionsProps as MentionsSuggestionsProps, index$w as Menu, type MenuAnchorProps, type MenuCheckboxItemProps, type MenuContentProps, type MenuGroupProps, type MenuItemIndicatorProps, type MenuItemProps, type MenuLabelProps, type MenuPortalProps, type MenuRadioGroupProps, type MenuRadioItemProps, type MenuRootProps, type MenuSeparatorProps, index$t as Menubar, type MenubarRootProps, type MenubarTriggerProps, index$n as MultiSelect, type MultiSelectContentProps, type MultiSelectCreateItemProps, type MultiSelectFilterOption, type MultiSelectItemProps, type MultiSelectItemTextProps, type MultiSelectOption, type MultiSelectOptionsProps, type MultiSelectPortalProps, type MultiSelectRootProps, type MultiSelectSearchInputProps, type MultiSelectSelectedOption, type MultiSelectTriggerProps, type MultiSelectValueProps, index$s as NavigationMenu, type NavigationMenuItemProps, type NavigationMenuLinkProps, type NavigationMenuRootProps, index$h as NumberField, type NumberFieldRootProps, type OhlcEntry, index$j as OneTimePasswordField, type OtpInputProps, type OtpRootProps, index$q as Pagination, type PaginationProps, index$i as PasswordToggleField, type PasswordToggleFieldRootProps, type PickerChangeContext, type PickerChangeSource, type PickerFieldSection, type PickerFormatDensity, type PickerLocaleText, type PickerOrientation, type PickerSelectedSections, type PickerShortcutMetadata, type PickerSlotProps, type PickerSlots, type PickerSx, type PickerSxValue, type PieContextValue, index$A as Popover, type PopoverAnchorProps, type PopoverArrowProps, type PopoverCloseProps, type PopoverContentProps, type PopoverPortalProps, type PopoverRootProps, type PopoverTriggerProps, type PopperProps, index$J as Progress, type ProgressIndicatorProps, type ProgressRootProps, type ProgressState, type RadarContextValue, index$I as RadioGroup, type RadioGroupIndicatorProps, type RadioGroupItemProps, type RadioGroupRootProps, Rating$1 as Rating, type RatingProps$1 as RatingProps, index$7 as Resizable, type ResizableGroupProps, type ResizableHandleProps, type ResizablePanelProps, type SankeyLink, type SankeyNode, type ScatterMarkerShape, index$9 as ScrollArea, type ScrollAreaRootProps, type ScrollbarProps as ScrollAreaScrollbarProps, index$o as Select, type SelectContentProps, type SelectCreateItemProps, type SelectFilterOption, type SelectItemProps, type SelectItemTextProps, type SelectOption, type SelectOptionsProps, type SelectPortalProps, type SelectRootProps, type SelectSearchInputProps, type SelectTriggerProps, type SelectValueProps, Separator, type SeparatorProps, Skeleton, type SkeletonProps, index$G as Slider, type SliderRangeProps, type SliderRootProps, type SliderThumbProps, type SliderTrackProps, Spinner, type SpinnerProps, index$p as Stepper, type StepperButtonProps, type StepperProps, index$l as Structyl, type BackdropProps as StructylBackdropProps, type BottomNavigationItemProps as StructylBottomNavigationItemProps, type BottomNavigationRootProps as StructylBottomNavigationRootProps, type ChartProps as StructylChartProps, type ClickAwayListenerProps as StructylClickAwayListenerProps, type InitColorSchemeScriptProps as StructylInitColorSchemeScriptProps, type ModalProps as StructylModalProps, type RatingProps as StructylRatingProps, type SnackbarOrigin as StructylSnackbarOrigin, type SnackbarProps as StructylSnackbarProps, type SpeedDialRootProps as StructylSpeedDialRootProps, type SpeedDialTriggerProps as StructylSpeedDialTriggerProps, type TextareaAutosizeProps as StructylTextareaAutosizeProps, type TransferListOption as StructylTransferListOption, type TransferListProps as StructylTransferListProps, type TransitionProps as StructylTransitionProps, type SunburstNode, type SwipeDirection, Switch, type SwitchProps, index$C as Tabs, type TabsContentProps, type TabsListProps, type TabsRootProps, type TabsTriggerProps, index$3 as TagsInput, type TagsInputRootProps, Textarea, type TextareaProps, index$e as TimePicker, type TimePickerFormat, type TimePickerRootProps, type TimePickerSegment, type SegmentProps$2 as TimePickerSegmentProps, type TimePickerValue, type TimePickerValueProps, type TimePickerView, type TimePickerViewRenderer, type TimeSteps, type TimeValidationError, type TimeValidationOptions, type TimeValue, index$x as Toast, type ToastActionProps, type ToastCloseProps, type ToastDescriptionProps, type ToastProviderProps, type ToastRootProps, type ToastTitleProps, type ToastViewportProps, Toggle, index$H as ToggleGroup, type ToggleGroupItemProps, type ToggleGroupMultipleProps, type ToggleGroupRootProps, type ToggleGroupSingleProps, type ToggleProps, index$8 as Toolbar, type ToolbarRootProps, index$z as Tooltip, type TooltipArrowProps, type TooltipContentProps, type TooltipPayloadEntry, type TooltipPortalProps, type TooltipProviderProps, type TooltipRootProps, type TooltipState, type TooltipTriggerProps, index$5 as Tree, type TreeItemProps, type TreeRootProps, type TreemapLayoutNode, type TreemapNode, type ValidityMatcher, type WaterfallEntry, addDays, addMonths, applyTimePart, clampDate, createPickerChangeContext, dateToTimeValue, hsvaToHex, isAfterDay, isBeforeDay, isSameDay, isSameMonth, isValidDate, mergeDateAndTime, pad, startOfDay, startOfMonth, timeValueToDate, validateDateTimeValue, validateDateValue, validateTimeValue };