import * as React from 'react';
import * as react_jsx_runtime from 'react/jsx-runtime';

interface AccessibleIconProps {
    children?: React.ReactNode;
    /**
     * The accessible label for the icon. This label will be visually hidden but announced to screen
     * reader users, similar to `alt` text for `img` tags.
     */
    label: string;
}
declare const AccessibleIcon: React.FC<AccessibleIconProps>;
declare const Root$p: React.FC<AccessibleIconProps>;

declare const index_d$y_AccessibleIcon: typeof AccessibleIcon;
type index_d$y_AccessibleIconProps = AccessibleIconProps;
declare namespace index_d$y {
  export { index_d$y_AccessibleIcon as AccessibleIcon, Root$p as Root };
  export type { index_d$y_AccessibleIconProps as AccessibleIconProps };
}

type Scope<C = any> = {
    [scopeName: string]: React.Context<C>[];
} | undefined;
type ScopeHook = (scope: Scope) => {
    [__scopeProp: string]: Scope;
};
interface CreateScope {
    scopeName: string;
    (): ScopeHook;
}

declare const NODES: readonly ["a", "button", "div", "form", "h2", "h3", "img", "input", "label", "li", "nav", "ol", "p", "select", "span", "svg", "ul"];
type Primitives = {
    [E in (typeof NODES)[number]]: PrimitiveForwardRefComponent<E>;
};
type PrimitivePropsWithRef<E extends React.ElementType> = React.ComponentPropsWithRef<E> & {
    asChild?: boolean;
};
interface PrimitiveForwardRefComponent<E extends React.ElementType> extends React.ForwardRefExoticComponent<PrimitivePropsWithRef<E>> {
}
declare const Primitive: Primitives;

declare const createCollapsibleScope: CreateScope;
type PrimitiveDivProps$m = React.ComponentPropsWithoutRef<typeof Primitive.div>;
interface CollapsibleProps$1 extends PrimitiveDivProps$m {
    defaultOpen?: boolean;
    open?: boolean;
    disabled?: boolean;
    onOpenChange?(open: boolean): void;
}
declare const Collapsible: React.ForwardRefExoticComponent<CollapsibleProps$1 & React.RefAttributes<HTMLDivElement>>;
type PrimitiveButtonProps$g = React.ComponentPropsWithoutRef<typeof Primitive.button>;
interface CollapsibleTriggerProps$1 extends PrimitiveButtonProps$g {
}
declare const CollapsibleTrigger: React.ForwardRefExoticComponent<CollapsibleTriggerProps$1 & React.RefAttributes<HTMLButtonElement>>;
interface CollapsibleContentProps$1 extends Omit<CollapsibleContentImplProps, 'present'> {
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: true;
}
declare const CollapsibleContent: React.ForwardRefExoticComponent<CollapsibleContentProps$1 & React.RefAttributes<HTMLDivElement>>;
interface CollapsibleContentImplProps extends PrimitiveDivProps$m {
    present: boolean;
}
declare const Root$o: React.ForwardRefExoticComponent<CollapsibleProps$1 & React.RefAttributes<HTMLDivElement>>;
declare const Trigger$a: React.ForwardRefExoticComponent<CollapsibleTriggerProps$1 & React.RefAttributes<HTMLButtonElement>>;
declare const Content$c: React.ForwardRefExoticComponent<CollapsibleContentProps$1 & React.RefAttributes<HTMLDivElement>>;

declare const index_d$x_Collapsible: typeof Collapsible;
declare const index_d$x_CollapsibleContent: typeof CollapsibleContent;
declare const index_d$x_CollapsibleTrigger: typeof CollapsibleTrigger;
declare const index_d$x_createCollapsibleScope: typeof createCollapsibleScope;
declare namespace index_d$x {
  export { index_d$x_Collapsible as Collapsible, index_d$x_CollapsibleContent as CollapsibleContent, index_d$x_CollapsibleTrigger as CollapsibleTrigger, Content$c as Content, Root$o as Root, Trigger$a as Trigger, index_d$x_createCollapsibleScope as createCollapsibleScope };
  export type { CollapsibleContentProps$1 as CollapsibleContentProps, CollapsibleProps$1 as CollapsibleProps, CollapsibleTriggerProps$1 as CollapsibleTriggerProps };
}

type Direction$8 = 'ltr' | 'rtl';
declare const createAccordionScope: CreateScope;
interface AccordionSingleProps extends AccordionImplSingleProps {
    type: 'single';
}
interface AccordionMultipleProps extends AccordionImplMultipleProps {
    type: 'multiple';
}
declare const Accordion: React.ForwardRefExoticComponent<(AccordionSingleProps | AccordionMultipleProps) & React.RefAttributes<HTMLDivElement>>;
interface AccordionImplSingleProps extends AccordionImplProps {
    /**
     * The controlled stateful value of the accordion item whose content is expanded.
     */
    value?: string;
    /**
     * The value of the item whose content is expanded when the accordion is initially rendered. Use
     * `defaultValue` if you do not need to control the state of an accordion.
     */
    defaultValue?: string;
    /**
     * The callback that fires when the state of the accordion changes.
     */
    onValueChange?(value: string): void;
    /**
     * Whether an accordion item can be collapsed after it has been opened.
     * @default false
     */
    collapsible?: boolean;
}
interface AccordionImplMultipleProps extends AccordionImplProps {
    /**
     * The controlled stateful value of the accordion items whose contents are expanded.
     */
    value?: string[];
    /**
     * The value of the items whose contents are expanded when the accordion is initially rendered. Use
     * `defaultValue` if you do not need to control the state of an accordion.
     */
    defaultValue?: string[];
    /**
     * The callback that fires when the state of the accordion changes.
     */
    onValueChange?(value: string[]): void;
}
type PrimitiveDivProps$l = React.ComponentPropsWithoutRef<typeof Primitive.div>;
interface AccordionImplProps extends PrimitiveDivProps$l {
    /**
     * Whether or not an accordion is disabled from user interaction.
     *
     * @defaultValue false
     */
    disabled?: boolean;
    /**
     * The layout in which the Accordion operates.
     * @default vertical
     */
    orientation?: React.AriaAttributes['aria-orientation'];
    /**
     * The language read direction.
     */
    dir?: Direction$8;
}
type CollapsibleProps = React.ComponentPropsWithoutRef<typeof Root$o>;
interface AccordionItemProps extends Omit<CollapsibleProps, 'open' | 'defaultOpen' | 'onOpenChange'> {
    /**
     * Whether or not an accordion item is disabled from user interaction.
     *
     * @defaultValue false
     */
    disabled?: boolean;
    /**
     * A string value for the accordion item. All items within an accordion should use a unique value.
     */
    value: string;
}
/**
 * `AccordionItem` contains all of the parts of a collapsible section inside of an `Accordion`.
 */
declare const AccordionItem: React.ForwardRefExoticComponent<AccordionItemProps & React.RefAttributes<HTMLDivElement>>;
type PrimitiveHeading3Props = React.ComponentPropsWithoutRef<typeof Primitive.h3>;
interface AccordionHeaderProps extends PrimitiveHeading3Props {
}
/**
 * `AccordionHeader` contains the content for the parts of an `AccordionItem` that will be visible
 * whether or not its content is collapsed.
 */
declare const AccordionHeader: React.ForwardRefExoticComponent<AccordionHeaderProps & React.RefAttributes<HTMLHeadingElement>>;
type CollapsibleTriggerProps = React.ComponentPropsWithoutRef<typeof Trigger$a>;
interface AccordionTriggerProps extends CollapsibleTriggerProps {
}
/**
 * `AccordionTrigger` is the trigger that toggles the collapsed state of an `AccordionItem`. It
 * should always be nested inside of an `AccordionHeader`.
 */
declare const AccordionTrigger: React.ForwardRefExoticComponent<AccordionTriggerProps & React.RefAttributes<HTMLButtonElement>>;
type CollapsibleContentProps = React.ComponentPropsWithoutRef<typeof Content$c>;
interface AccordionContentProps extends CollapsibleContentProps {
}
/**
 * `AccordionContent` contains the collapsible content for an `AccordionItem`.
 */
declare const AccordionContent: React.ForwardRefExoticComponent<AccordionContentProps & React.RefAttributes<HTMLDivElement>>;
declare const Root$n: React.ForwardRefExoticComponent<(AccordionSingleProps | AccordionMultipleProps) & React.RefAttributes<HTMLDivElement>>;
declare const Item$5: React.ForwardRefExoticComponent<AccordionItemProps & React.RefAttributes<HTMLDivElement>>;
declare const Header: React.ForwardRefExoticComponent<AccordionHeaderProps & React.RefAttributes<HTMLHeadingElement>>;
declare const Trigger$9: React.ForwardRefExoticComponent<AccordionTriggerProps & React.RefAttributes<HTMLButtonElement>>;
declare const Content$b: React.ForwardRefExoticComponent<AccordionContentProps & React.RefAttributes<HTMLDivElement>>;

declare const index_d$w_Accordion: typeof Accordion;
declare const index_d$w_AccordionContent: typeof AccordionContent;
type index_d$w_AccordionContentProps = AccordionContentProps;
declare const index_d$w_AccordionHeader: typeof AccordionHeader;
type index_d$w_AccordionHeaderProps = AccordionHeaderProps;
declare const index_d$w_AccordionItem: typeof AccordionItem;
type index_d$w_AccordionItemProps = AccordionItemProps;
type index_d$w_AccordionMultipleProps = AccordionMultipleProps;
type index_d$w_AccordionSingleProps = AccordionSingleProps;
declare const index_d$w_AccordionTrigger: typeof AccordionTrigger;
type index_d$w_AccordionTriggerProps = AccordionTriggerProps;
declare const index_d$w_Header: typeof Header;
declare const index_d$w_createAccordionScope: typeof createAccordionScope;
declare namespace index_d$w {
  export { index_d$w_Accordion as Accordion, index_d$w_AccordionContent as AccordionContent, index_d$w_AccordionHeader as AccordionHeader, index_d$w_AccordionItem as AccordionItem, index_d$w_AccordionTrigger as AccordionTrigger, Content$b as Content, index_d$w_Header as Header, Item$5 as Item, Root$n as Root, Trigger$9 as Trigger, index_d$w_createAccordionScope as createAccordionScope };
  export type { index_d$w_AccordionContentProps as AccordionContentProps, index_d$w_AccordionHeaderProps as AccordionHeaderProps, index_d$w_AccordionItemProps as AccordionItemProps, index_d$w_AccordionMultipleProps as AccordionMultipleProps, index_d$w_AccordionSingleProps as AccordionSingleProps, index_d$w_AccordionTriggerProps as AccordionTriggerProps };
}

type PrimitiveDivProps$k = React.ComponentPropsWithoutRef<typeof Primitive.div>;
interface DismissableLayerProps$8 extends PrimitiveDivProps$k {
    /**
     * When `true`, hover/focus/click interactions will be disabled on elements outside
     * the `DismissableLayer`. Users will need to click twice on outside elements to
     * interact with them: once to close the `DismissableLayer`, and again to trigger the element.
     */
    disableOutsidePointerEvents?: boolean;
    /**
     * When `true`, a `'pointerdown'` event outside of the layered element will
     * wait for the interaction's click event before dispatching, allowing
     * third-party code to stop propagation of later events and cancel dismissal.
     */
    deferPointerDownOutside?: boolean;
    /**
     * Event handler called when the escape key is down.
     * Can be prevented.
     */
    onEscapeKeyDown?: (event: KeyboardEvent) => void;
    /**
     * Event handler called when the a `pointerdown` event happens outside of the `DismissableLayer`.
     * Can be prevented.
     */
    onPointerDownOutside?: (event: PointerDownOutsideEvent) => void;
    /**
     * Event handler called when the focus moves outside of the `DismissableLayer`.
     * Can be prevented.
     */
    onFocusOutside?: (event: FocusOutsideEvent) => void;
    /**
     * Event handler called when an interaction happens outside the `DismissableLayer`.
     * Specifically, when a `pointerdown` event happens outside or focus moves outside of it.
     * Can be prevented.
     */
    onInteractOutside?: (event: PointerDownOutsideEvent | FocusOutsideEvent) => void;
    /**
     * Handler called when the `DismissableLayer` should be dismissed
     */
    onDismiss?: () => void;
}
declare const DismissableLayer: React.ForwardRefExoticComponent<DismissableLayerProps$8 & React.RefAttributes<HTMLDivElement>>;
type PointerDownOutsideEvent = CustomEvent<{
    originalEvent: PointerEvent;
}>;
type FocusOutsideEvent = CustomEvent<{
    originalEvent: FocusEvent;
}>;
declare const Root$m: React.ForwardRefExoticComponent<DismissableLayerProps$8 & React.RefAttributes<HTMLDivElement>>;

type PrimitiveDivProps$j = React.ComponentPropsWithoutRef<typeof Primitive.div>;
interface FocusScopeProps$4 extends PrimitiveDivProps$j {
    /**
     * When `true`, tabbing from last item will focus first tabbable
     * and shift+tab from first item will focus last tababble.
     * @defaultValue false
     */
    loop?: boolean;
    /**
     * When `true`, focus cannot escape the focus scope via keyboard,
     * pointer, or a programmatic focus.
     * @defaultValue false
     */
    trapped?: boolean;
    /**
     * Event handler called when auto-focusing on mount.
     * Can be prevented.
     */
    onMountAutoFocus?: (event: Event) => void;
    /**
     * Event handler called when auto-focusing on unmount.
     * Can be prevented.
     */
    onUnmountAutoFocus?: (event: Event) => void;
}
declare const FocusScope: React.ForwardRefExoticComponent<FocusScopeProps$4 & React.RefAttributes<HTMLDivElement>>;

type PrimitiveDivProps$i = React.ComponentPropsWithoutRef<typeof Primitive.div>;
interface PortalProps$6 extends PrimitiveDivProps$i {
    /**
     * An optional container where the portaled content should be appended.
     */
    container?: Element | DocumentFragment | null;
}
declare const Portal$8: React.ForwardRefExoticComponent<PortalProps$6 & React.RefAttributes<HTMLDivElement>>;
declare const Root$l: React.ForwardRefExoticComponent<PortalProps$6 & React.RefAttributes<HTMLDivElement>>;

declare namespace index_d$v {
  export { Portal$8 as Portal, Root$l as Root };
  export type { PortalProps$6 as PortalProps };
}

type ScopedProps$7<P> = P & {
    __scopeDialog?: Scope;
};
declare const createDialogScope: CreateScope;
interface DialogProps$1 {
    children?: React.ReactNode;
    open?: boolean;
    defaultOpen?: boolean;
    onOpenChange?(open: boolean): void;
    modal?: boolean;
}
declare const Dialog: React.FC<DialogProps$1>;
type PrimitiveButtonProps$f = React.ComponentPropsWithoutRef<typeof Primitive.button>;
interface DialogTriggerProps$1 extends PrimitiveButtonProps$f {
}
declare const DialogTrigger: React.ForwardRefExoticComponent<DialogTriggerProps$1 & React.RefAttributes<HTMLButtonElement>>;
type PortalProps$5 = React.ComponentPropsWithoutRef<typeof Portal$8>;
interface DialogPortalProps$1 {
    children?: React.ReactNode;
    /**
     * Specify a container element to portal the content into.
     */
    container?: PortalProps$5['container'];
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: true;
}
declare const DialogPortal: React.FC<DialogPortalProps$1>;
interface DialogOverlayProps$1 extends DialogOverlayImplProps {
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: true;
}
declare const DialogOverlay: React.ForwardRefExoticComponent<DialogOverlayProps$1 & React.RefAttributes<HTMLDivElement>>;
type PrimitiveDivProps$h = React.ComponentPropsWithoutRef<typeof Primitive.div>;
interface DialogOverlayImplProps extends PrimitiveDivProps$h {
}
interface DialogContentProps$1 extends DialogContentTypeProps {
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: true;
}
declare const DialogContent: React.ForwardRefExoticComponent<DialogContentProps$1 & React.RefAttributes<HTMLDivElement>>;
interface DialogContentTypeProps extends Omit<DialogContentImplProps, 'trapFocus' | 'disableOutsidePointerEvents'> {
}
type DismissableLayerProps$7 = React.ComponentPropsWithoutRef<typeof DismissableLayer>;
type FocusScopeProps$3 = React.ComponentPropsWithoutRef<typeof FocusScope>;
interface DialogContentImplProps extends Omit<DismissableLayerProps$7, 'onDismiss'> {
    /**
     * When `true`, focus cannot escape the `Content` via keyboard,
     * pointer, or a programmatic focus.
     * @defaultValue false
     */
    trapFocus?: FocusScopeProps$3['trapped'];
    /**
     * Event handler called when auto-focusing on open.
     * Can be prevented.
     */
    onOpenAutoFocus?: FocusScopeProps$3['onMountAutoFocus'];
    /**
     * Event handler called when auto-focusing on close.
     * Can be prevented.
     */
    onCloseAutoFocus?: FocusScopeProps$3['onUnmountAutoFocus'];
}
type PrimitiveHeading2Props = React.ComponentPropsWithoutRef<typeof Primitive.h2>;
interface DialogTitleProps$1 extends PrimitiveHeading2Props {
}
declare const DialogTitle: React.ForwardRefExoticComponent<DialogTitleProps$1 & React.RefAttributes<HTMLHeadingElement>>;
type PrimitiveParagraphProps = React.ComponentPropsWithoutRef<typeof Primitive.p>;
interface DialogDescriptionProps$1 extends PrimitiveParagraphProps {
}
declare const DialogDescription: React.ForwardRefExoticComponent<DialogDescriptionProps$1 & React.RefAttributes<HTMLParagraphElement>>;
interface DialogCloseProps$1 extends PrimitiveButtonProps$f {
}
declare const DialogClose: React.ForwardRefExoticComponent<DialogCloseProps$1 & React.RefAttributes<HTMLButtonElement>>;
/** @deprecated Noop component to avoid breaking changes. */
declare const WarningProvider: React.FC<ScopedProps$7<{
    children?: React.ReactNode;
    contentName: string;
    titleName: string;
    docsSlug: 'dialog';
}>>;

declare const index_d$u_Dialog: typeof Dialog;
declare const index_d$u_DialogClose: typeof DialogClose;
declare const index_d$u_DialogContent: typeof DialogContent;
declare const index_d$u_DialogDescription: typeof DialogDescription;
declare const index_d$u_DialogOverlay: typeof DialogOverlay;
declare const index_d$u_DialogPortal: typeof DialogPortal;
declare const index_d$u_DialogTitle: typeof DialogTitle;
declare const index_d$u_DialogTrigger: typeof DialogTrigger;
declare const index_d$u_WarningProvider: typeof WarningProvider;
declare const index_d$u_createDialogScope: typeof createDialogScope;
declare namespace index_d$u {
  export { DialogClose as Close, DialogContent as Content, DialogDescription as Description, index_d$u_Dialog as Dialog, index_d$u_DialogClose as DialogClose, index_d$u_DialogContent as DialogContent, index_d$u_DialogDescription as DialogDescription, index_d$u_DialogOverlay as DialogOverlay, index_d$u_DialogPortal as DialogPortal, index_d$u_DialogTitle as DialogTitle, index_d$u_DialogTrigger as DialogTrigger, DialogOverlay as Overlay, DialogPortal as Portal, Dialog as Root, DialogTitle as Title, DialogTrigger as Trigger, index_d$u_WarningProvider as WarningProvider, index_d$u_createDialogScope as createDialogScope };
  export type { DialogCloseProps$1 as DialogCloseProps, DialogContentProps$1 as DialogContentProps, DialogDescriptionProps$1 as DialogDescriptionProps, DialogOverlayProps$1 as DialogOverlayProps, DialogPortalProps$1 as DialogPortalProps, DialogProps$1 as DialogProps, DialogTitleProps$1 as DialogTitleProps, DialogTriggerProps$1 as DialogTriggerProps };
}

declare const createAlertDialogScope: CreateScope;
type DialogProps = React.ComponentPropsWithoutRef<typeof Dialog>;
interface AlertDialogProps extends Omit<DialogProps, 'modal'> {
}
declare const AlertDialog: React.FC<AlertDialogProps>;
type DialogTriggerProps = React.ComponentPropsWithoutRef<typeof DialogTrigger>;
interface AlertDialogTriggerProps extends DialogTriggerProps {
}
declare const AlertDialogTrigger: React.ForwardRefExoticComponent<AlertDialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
type DialogPortalProps = React.ComponentPropsWithoutRef<typeof DialogPortal>;
interface AlertDialogPortalProps extends DialogPortalProps {
}
declare const AlertDialogPortal: React.FC<AlertDialogPortalProps>;
type DialogOverlayProps = React.ComponentPropsWithoutRef<typeof DialogOverlay>;
interface AlertDialogOverlayProps extends DialogOverlayProps {
}
declare const AlertDialogOverlay: React.ForwardRefExoticComponent<AlertDialogOverlayProps & React.RefAttributes<HTMLDivElement>>;
type DialogContentProps = React.ComponentPropsWithoutRef<typeof DialogContent>;
interface AlertDialogContentProps extends Omit<DialogContentProps, 'onPointerDownOutside' | 'onInteractOutside'> {
}
declare const AlertDialogContent: React.ForwardRefExoticComponent<AlertDialogContentProps & React.RefAttributes<HTMLDivElement>>;
type DialogTitleProps = React.ComponentPropsWithoutRef<typeof DialogTitle>;
interface AlertDialogTitleProps extends DialogTitleProps {
}
declare const AlertDialogTitle: React.ForwardRefExoticComponent<AlertDialogTitleProps & React.RefAttributes<HTMLHeadingElement>>;
type DialogDescriptionProps = React.ComponentPropsWithoutRef<typeof DialogDescription>;
interface AlertDialogDescriptionProps extends DialogDescriptionProps {
}
declare const AlertDialogDescription: React.ForwardRefExoticComponent<AlertDialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>>;
type DialogCloseProps = React.ComponentPropsWithoutRef<typeof DialogClose>;
interface AlertDialogActionProps extends DialogCloseProps {
}
declare const AlertDialogAction: React.ForwardRefExoticComponent<AlertDialogActionProps & React.RefAttributes<HTMLButtonElement>>;
interface AlertDialogCancelProps extends DialogCloseProps {
}
declare const AlertDialogCancel: React.ForwardRefExoticComponent<AlertDialogCancelProps & React.RefAttributes<HTMLButtonElement>>;
declare const Root$k: React.FC<AlertDialogProps>;
declare const Trigger$8: React.ForwardRefExoticComponent<AlertDialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
declare const Portal$7: React.FC<AlertDialogPortalProps>;
declare const Overlay: React.ForwardRefExoticComponent<AlertDialogOverlayProps & React.RefAttributes<HTMLDivElement>>;
declare const Content$a: React.ForwardRefExoticComponent<AlertDialogContentProps & React.RefAttributes<HTMLDivElement>>;
declare const Action$1: React.ForwardRefExoticComponent<AlertDialogActionProps & React.RefAttributes<HTMLButtonElement>>;
declare const Cancel: React.ForwardRefExoticComponent<AlertDialogCancelProps & React.RefAttributes<HTMLButtonElement>>;
declare const Title$1: React.ForwardRefExoticComponent<AlertDialogTitleProps & React.RefAttributes<HTMLHeadingElement>>;
declare const Description$1: React.ForwardRefExoticComponent<AlertDialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>>;

declare const index_d$t_AlertDialog: typeof AlertDialog;
declare const index_d$t_AlertDialogAction: typeof AlertDialogAction;
type index_d$t_AlertDialogActionProps = AlertDialogActionProps;
declare const index_d$t_AlertDialogCancel: typeof AlertDialogCancel;
type index_d$t_AlertDialogCancelProps = AlertDialogCancelProps;
declare const index_d$t_AlertDialogContent: typeof AlertDialogContent;
type index_d$t_AlertDialogContentProps = AlertDialogContentProps;
declare const index_d$t_AlertDialogDescription: typeof AlertDialogDescription;
type index_d$t_AlertDialogDescriptionProps = AlertDialogDescriptionProps;
declare const index_d$t_AlertDialogOverlay: typeof AlertDialogOverlay;
type index_d$t_AlertDialogOverlayProps = AlertDialogOverlayProps;
declare const index_d$t_AlertDialogPortal: typeof AlertDialogPortal;
type index_d$t_AlertDialogPortalProps = AlertDialogPortalProps;
type index_d$t_AlertDialogProps = AlertDialogProps;
declare const index_d$t_AlertDialogTitle: typeof AlertDialogTitle;
type index_d$t_AlertDialogTitleProps = AlertDialogTitleProps;
declare const index_d$t_AlertDialogTrigger: typeof AlertDialogTrigger;
type index_d$t_AlertDialogTriggerProps = AlertDialogTriggerProps;
declare const index_d$t_Cancel: typeof Cancel;
declare const index_d$t_Overlay: typeof Overlay;
declare const index_d$t_createAlertDialogScope: typeof createAlertDialogScope;
declare namespace index_d$t {
  export { Action$1 as Action, index_d$t_AlertDialog as AlertDialog, index_d$t_AlertDialogAction as AlertDialogAction, index_d$t_AlertDialogCancel as AlertDialogCancel, index_d$t_AlertDialogContent as AlertDialogContent, index_d$t_AlertDialogDescription as AlertDialogDescription, index_d$t_AlertDialogOverlay as AlertDialogOverlay, index_d$t_AlertDialogPortal as AlertDialogPortal, index_d$t_AlertDialogTitle as AlertDialogTitle, index_d$t_AlertDialogTrigger as AlertDialogTrigger, index_d$t_Cancel as Cancel, Content$a as Content, Description$1 as Description, index_d$t_Overlay as Overlay, Portal$7 as Portal, Root$k as Root, Title$1 as Title, Trigger$8 as Trigger, index_d$t_createAlertDialogScope as createAlertDialogScope };
  export type { index_d$t_AlertDialogActionProps as AlertDialogActionProps, index_d$t_AlertDialogCancelProps as AlertDialogCancelProps, index_d$t_AlertDialogContentProps as AlertDialogContentProps, index_d$t_AlertDialogDescriptionProps as AlertDialogDescriptionProps, index_d$t_AlertDialogOverlayProps as AlertDialogOverlayProps, index_d$t_AlertDialogPortalProps as AlertDialogPortalProps, index_d$t_AlertDialogProps as AlertDialogProps, index_d$t_AlertDialogTitleProps as AlertDialogTitleProps, index_d$t_AlertDialogTriggerProps as AlertDialogTriggerProps };
}

type PrimitiveDivProps$g = React.ComponentPropsWithoutRef<typeof Primitive.div>;
interface AspectRatioProps extends PrimitiveDivProps$g {
    ratio?: number;
}
declare const AspectRatio: React.ForwardRefExoticComponent<AspectRatioProps & React.RefAttributes<HTMLDivElement>>;
declare const Root$j: React.ForwardRefExoticComponent<AspectRatioProps & React.RefAttributes<HTMLDivElement>>;

declare const index_d$s_AspectRatio: typeof AspectRatio;
type index_d$s_AspectRatioProps = AspectRatioProps;
declare namespace index_d$s {
  export { index_d$s_AspectRatio as AspectRatio, Root$j as Root };
  export type { index_d$s_AspectRatioProps as AspectRatioProps };
}

declare const createAvatarScope: CreateScope;
type ImageLoadingStatus = 'idle' | 'loading' | 'loaded' | 'error';
type PrimitiveSpanProps$9 = React.ComponentPropsWithoutRef<typeof Primitive.span>;
interface AvatarProps extends PrimitiveSpanProps$9 {
}
declare const Avatar: React.ForwardRefExoticComponent<AvatarProps & React.RefAttributes<HTMLSpanElement>>;
type PrimitiveImageProps = React.ComponentPropsWithoutRef<typeof Primitive.img>;
interface AvatarImageProps extends PrimitiveImageProps {
    onLoadingStatusChange?: (status: ImageLoadingStatus) => void;
}
declare const AvatarImage: React.ForwardRefExoticComponent<AvatarImageProps & React.RefAttributes<HTMLImageElement>>;
interface AvatarFallbackProps extends PrimitiveSpanProps$9 {
    delayMs?: number;
}
declare const AvatarFallback: React.ForwardRefExoticComponent<AvatarFallbackProps & React.RefAttributes<HTMLSpanElement>>;

declare const index_d$r_Avatar: typeof Avatar;
declare const index_d$r_AvatarFallback: typeof AvatarFallback;
type index_d$r_AvatarFallbackProps = AvatarFallbackProps;
declare const index_d$r_AvatarImage: typeof AvatarImage;
type index_d$r_AvatarImageProps = AvatarImageProps;
type index_d$r_AvatarProps = AvatarProps;
declare const index_d$r_createAvatarScope: typeof createAvatarScope;
declare namespace index_d$r {
  export { index_d$r_Avatar as Avatar, index_d$r_AvatarFallback as AvatarFallback, index_d$r_AvatarImage as AvatarImage, AvatarFallback as Fallback, AvatarImage as Image, Avatar as Root, index_d$r_createAvatarScope as createAvatarScope };
  export type { index_d$r_AvatarFallbackProps as AvatarFallbackProps, index_d$r_AvatarImageProps as AvatarImageProps, index_d$r_AvatarProps as AvatarProps };
}

type ScopedProps$6<P> = P & {
    __scopeCheckbox?: Scope;
};
declare const createCheckboxScope: CreateScope;
type CheckedState$1 = boolean | 'indeterminate';
interface CheckboxProviderProps<State extends CheckedState$1 = CheckedState$1> {
    checked?: State | boolean;
    defaultChecked?: State | boolean;
    required?: boolean;
    onCheckedChange?(checked: State | boolean): void;
    name?: string;
    form?: string;
    disabled?: boolean;
    value?: string | number | readonly string[];
    children?: React.ReactNode;
}
declare function CheckboxProvider<State extends CheckedState$1 = CheckedState$1>(props: ScopedProps$6<CheckboxProviderProps<State>>): react_jsx_runtime.JSX.Element;
interface CheckboxTriggerProps extends Omit<React.ComponentPropsWithoutRef<typeof Primitive.button>, keyof CheckboxProviderProps> {
    children?: React.ReactNode;
}
declare const CheckboxTrigger: React.ForwardRefExoticComponent<CheckboxTriggerProps & React.RefAttributes<HTMLButtonElement>>;
type PrimitiveButtonProps$e = React.ComponentPropsWithoutRef<typeof Primitive.button>;
interface CheckboxProps extends Omit<PrimitiveButtonProps$e, 'checked' | 'defaultChecked'> {
    checked?: CheckedState$1;
    defaultChecked?: CheckedState$1;
    required?: boolean;
    onCheckedChange?(checked: CheckedState$1): void;
}
declare const Checkbox: React.ForwardRefExoticComponent<CheckboxProps & React.RefAttributes<HTMLButtonElement>>;
type PrimitiveSpanProps$8 = React.ComponentPropsWithoutRef<typeof Primitive.span>;
interface CheckboxIndicatorProps extends PrimitiveSpanProps$8 {
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: true;
}
declare const CheckboxIndicator: React.ForwardRefExoticComponent<CheckboxIndicatorProps & React.RefAttributes<HTMLSpanElement>>;
type InputProps$2 = React.ComponentPropsWithoutRef<typeof Primitive.input>;
interface CheckboxBubbleInputProps extends Omit<InputProps$2, 'checked'> {
}
declare const CheckboxBubbleInput: React.ForwardRefExoticComponent<CheckboxBubbleInputProps & React.RefAttributes<HTMLInputElement>>;

declare const index_d$q_Checkbox: typeof Checkbox;
declare const index_d$q_CheckboxIndicator: typeof CheckboxIndicator;
type index_d$q_CheckboxIndicatorProps = CheckboxIndicatorProps;
type index_d$q_CheckboxProps = CheckboxProps;
declare const index_d$q_createCheckboxScope: typeof createCheckboxScope;
declare namespace index_d$q {
  export { index_d$q_Checkbox as Checkbox, index_d$q_CheckboxIndicator as CheckboxIndicator, CheckboxIndicator as Indicator, Checkbox as Root, index_d$q_createCheckboxScope as createCheckboxScope, CheckboxBubbleInput as unstable_BubbleInput, CheckboxBubbleInput as unstable_CheckboxBubbleInput, CheckboxProvider as unstable_CheckboxProvider, CheckboxTrigger as unstable_CheckboxTrigger, CheckboxProvider as unstable_Provider, CheckboxTrigger as unstable_Trigger };
  export type { index_d$q_CheckboxIndicatorProps as CheckboxIndicatorProps, index_d$q_CheckboxProps as CheckboxProps, CheckedState$1 as CheckedState, CheckboxBubbleInputProps as unstable_CheckboxBubbleInputProps, CheckboxProviderProps as unstable_CheckboxProviderProps, CheckboxTriggerProps as unstable_CheckboxTriggerProps };
}

type PrimitiveSvgProps$1 = React.ComponentPropsWithoutRef<typeof Primitive.svg>;
interface ArrowProps$1 extends PrimitiveSvgProps$1 {
}
declare const Root$i: React.ForwardRefExoticComponent<ArrowProps$1 & React.RefAttributes<SVGSVGElement>>;

type Measurable = {
    getBoundingClientRect(): DOMRect;
};

declare const SIDE_OPTIONS: readonly ["top", "right", "bottom", "left"];
declare const ALIGN_OPTIONS: readonly ["start", "center", "end"];
type Side = (typeof SIDE_OPTIONS)[number];
type Align = (typeof ALIGN_OPTIONS)[number];
type PrimitiveDivProps$f = React.ComponentPropsWithoutRef<typeof Primitive.div>;
interface PopperAnchorProps$1 extends PrimitiveDivProps$f {
    virtualRef?: React.RefObject<Measurable | null>;
}
type Boundary = Element | null;
interface PopperContentProps$5 extends PrimitiveDivProps$f {
    side?: Side;
    sideOffset?: number;
    align?: Align;
    alignOffset?: number;
    arrowPadding?: number;
    avoidCollisions?: boolean;
    collisionBoundary?: Boundary | Boundary[];
    collisionPadding?: number | Partial<Record<Side, number>>;
    sticky?: 'partial' | 'always';
    hideWhenDetached?: boolean;
    updatePositionStrategy?: 'optimized' | 'always';
    onPlaced?: () => void;
}
type ArrowProps = React.ComponentPropsWithoutRef<typeof Root$i>;
interface PopperArrowProps$5 extends ArrowProps {
}
declare const Anchor$1: React.ForwardRefExoticComponent<PopperAnchorProps$1 & React.RefAttributes<HTMLDivElement>>;
declare const Content$9: React.ForwardRefExoticComponent<PopperContentProps$5 & React.RefAttributes<HTMLDivElement>>;
declare const Arrow$7: React.ForwardRefExoticComponent<PopperArrowProps$5 & React.RefAttributes<SVGSVGElement>>;

type Orientation$2 = React.AriaAttributes['aria-orientation'];
type Direction$7 = 'ltr' | 'rtl';
interface RovingFocusGroupOptions {
    /**
     * The orientation of the group.
     * Mainly so arrow navigation is done accordingly (left & right vs. up & down)
     */
    orientation?: Orientation$2;
    /**
     * The direction of navigation between items.
     */
    dir?: Direction$7;
    /**
     * Whether keyboard navigation should loop around
     * @defaultValue false
     */
    loop?: boolean;
}
interface RovingFocusGroupProps$7 extends RovingFocusGroupImplProps {
}
type PrimitiveDivProps$e = React.ComponentPropsWithoutRef<typeof Primitive.div>;
interface RovingFocusGroupImplProps extends Omit<PrimitiveDivProps$e, 'dir'>, RovingFocusGroupOptions {
    currentTabStopId?: string | null;
    defaultCurrentTabStopId?: string;
    onCurrentTabStopIdChange?: (tabStopId: string | null) => void;
    onEntryFocus?: (event: Event) => void;
    preventScrollOnEntryFocus?: boolean;
}
declare const Root$h: React.ForwardRefExoticComponent<RovingFocusGroupProps$7 & React.RefAttributes<HTMLDivElement>>;

type PortalProps$4 = React.ComponentPropsWithoutRef<typeof Portal$8>;
interface MenuPortalProps$3 {
    children?: React.ReactNode;
    /**
     * Specify a container element to portal the content into.
     */
    container?: PortalProps$4['container'];
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: true;
}
/**
 * We purposefully don't union MenuRootContent and MenuSubContent props here because
 * they have conflicting prop types. We agreed that we would allow MenuSubContent to
 * accept props that it would just ignore.
 */
interface MenuContentProps$3 extends MenuRootContentTypeProps {
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: true;
}
interface MenuRootContentTypeProps extends Omit<MenuContentImplProps, keyof MenuContentImplPrivateProps> {
}
type FocusScopeProps$2 = React.ComponentPropsWithoutRef<typeof FocusScope>;
type DismissableLayerProps$6 = React.ComponentPropsWithoutRef<typeof DismissableLayer>;
type RovingFocusGroupProps$6 = React.ComponentPropsWithoutRef<typeof Root$h>;
type PopperContentProps$4 = React.ComponentPropsWithoutRef<typeof Content$9>;
type MenuContentImplPrivateProps = {
    onOpenAutoFocus?: FocusScopeProps$2['onMountAutoFocus'];
    onDismiss?: DismissableLayerProps$6['onDismiss'];
    disableOutsidePointerEvents?: DismissableLayerProps$6['disableOutsidePointerEvents'];
    /**
     * Whether scrolling outside the `MenuContent` should be prevented
     * (default: `false`)
     */
    disableOutsideScroll?: boolean;
    /**
     * Whether focus should be trapped within the `MenuContent`
     * (default: false)
     */
    trapFocus?: FocusScopeProps$2['trapped'];
};
interface MenuContentImplProps extends MenuContentImplPrivateProps, Omit<PopperContentProps$4, 'dir' | 'onPlaced'> {
    /**
     * Event handler called when auto-focusing on close.
     * Can be prevented.
     */
    onCloseAutoFocus?: FocusScopeProps$2['onUnmountAutoFocus'];
    /**
     * Whether keyboard navigation should loop around
     * @defaultValue false
     */
    loop?: RovingFocusGroupProps$6['loop'];
    onEntryFocus?: RovingFocusGroupProps$6['onEntryFocus'];
    onEscapeKeyDown?: DismissableLayerProps$6['onEscapeKeyDown'];
    onPointerDownOutside?: DismissableLayerProps$6['onPointerDownOutside'];
    onFocusOutside?: DismissableLayerProps$6['onFocusOutside'];
    onInteractOutside?: DismissableLayerProps$6['onInteractOutside'];
}
type PrimitiveDivProps$d = React.ComponentPropsWithoutRef<typeof Primitive.div>;
interface MenuGroupProps$3 extends PrimitiveDivProps$d {
}
interface MenuLabelProps$3 extends PrimitiveDivProps$d {
}
interface MenuItemProps$3 extends Omit<MenuItemImplProps, 'onSelect'> {
    onSelect?: (event: Event) => void;
}
interface MenuItemImplProps extends PrimitiveDivProps$d {
    disabled?: boolean;
    textValue?: string;
}
type CheckedState = boolean | 'indeterminate';
interface MenuCheckboxItemProps$3 extends MenuItemProps$3 {
    checked?: CheckedState;
    onCheckedChange?: (checked: boolean) => void;
}
interface MenuRadioGroupProps$3 extends MenuGroupProps$3 {
    value?: string;
    onValueChange?: (value: string) => void;
}
interface MenuRadioItemProps$3 extends MenuItemProps$3 {
    value: string;
}
type PrimitiveSpanProps$7 = React.ComponentPropsWithoutRef<typeof Primitive.span>;
interface MenuItemIndicatorProps$3 extends PrimitiveSpanProps$7 {
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: true;
}
interface MenuSeparatorProps$3 extends PrimitiveDivProps$d {
}
type PopperArrowProps$4 = React.ComponentPropsWithoutRef<typeof Arrow$7>;
interface MenuArrowProps$3 extends PopperArrowProps$4 {
}
interface MenuSubTriggerProps$3 extends MenuItemImplProps {
}
type AlignSubContent = Exclude<(typeof ALIGN_OPTIONS)[number], 'center'>;
interface MenuSubContentProps$3 extends Omit<MenuContentImplProps, keyof MenuContentImplPrivateProps | 'onCloseAutoFocus' | 'onEntryFocus' | 'side' | 'align'> {
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: true;
    /**
     * Controls the direction the subcontent appears from its anchor menu item
     * Default: start
     */
    align?: AlignSubContent;
}
declare const Portal$6: React.FC<MenuPortalProps$3>;
declare const Content$8: React.ForwardRefExoticComponent<MenuContentProps$3 & React.RefAttributes<HTMLDivElement>>;
declare const Group$3: React.ForwardRefExoticComponent<MenuGroupProps$3 & React.RefAttributes<HTMLDivElement>>;
declare const Label$5: React.ForwardRefExoticComponent<MenuLabelProps$3 & React.RefAttributes<HTMLDivElement>>;
declare const Item$4: React.ForwardRefExoticComponent<MenuItemProps$3 & React.RefAttributes<HTMLDivElement>>;
declare const CheckboxItem$3: React.ForwardRefExoticComponent<MenuCheckboxItemProps$3 & React.RefAttributes<HTMLDivElement>>;
declare const RadioGroup$4: React.ForwardRefExoticComponent<MenuRadioGroupProps$3 & React.RefAttributes<HTMLDivElement>>;
declare const RadioItem$3: React.ForwardRefExoticComponent<MenuRadioItemProps$3 & React.RefAttributes<HTMLDivElement>>;
declare const ItemIndicator$3: React.ForwardRefExoticComponent<MenuItemIndicatorProps$3 & React.RefAttributes<HTMLSpanElement>>;
declare const Separator$5: React.ForwardRefExoticComponent<MenuSeparatorProps$3 & React.RefAttributes<HTMLDivElement>>;
declare const Arrow$6: React.ForwardRefExoticComponent<MenuArrowProps$3 & React.RefAttributes<SVGSVGElement>>;
declare const SubTrigger$3: React.ForwardRefExoticComponent<MenuSubTriggerProps$3 & React.RefAttributes<HTMLDivElement>>;
declare const SubContent$3: React.ForwardRefExoticComponent<MenuSubContentProps$3 & React.RefAttributes<HTMLDivElement>>;

type Direction$6 = 'ltr' | 'rtl';
declare const createContextMenuScope: CreateScope;
interface ContextMenuProps {
    children?: React.ReactNode;
    open?: boolean;
    onOpenChange?(open: boolean): void;
    dir?: Direction$6;
    modal?: boolean;
}
declare const ContextMenu: React.FC<ContextMenuProps>;
type PrimitiveSpanProps$6 = React.ComponentPropsWithoutRef<typeof Primitive.span>;
interface ContextMenuTriggerProps extends PrimitiveSpanProps$6 {
    disabled?: boolean;
}
declare const ContextMenuTrigger: React.ForwardRefExoticComponent<ContextMenuTriggerProps & React.RefAttributes<HTMLSpanElement>>;
type MenuPortalProps$2 = React.ComponentPropsWithoutRef<typeof Portal$6>;
interface ContextMenuPortalProps extends MenuPortalProps$2 {
}
declare const ContextMenuPortal: React.FC<ContextMenuPortalProps>;
type MenuContentProps$2 = React.ComponentPropsWithoutRef<typeof Content$8>;
interface ContextMenuContentProps extends Omit<MenuContentProps$2, 'onEntryFocus' | 'side' | 'sideOffset' | 'align'> {
}
declare const ContextMenuContent: React.ForwardRefExoticComponent<ContextMenuContentProps & React.RefAttributes<HTMLDivElement>>;
type MenuGroupProps$2 = React.ComponentPropsWithoutRef<typeof Group$3>;
interface ContextMenuGroupProps extends MenuGroupProps$2 {
}
declare const ContextMenuGroup: React.ForwardRefExoticComponent<ContextMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
type MenuLabelProps$2 = React.ComponentPropsWithoutRef<typeof Label$5>;
interface ContextMenuLabelProps extends MenuLabelProps$2 {
}
declare const ContextMenuLabel: React.ForwardRefExoticComponent<ContextMenuLabelProps & React.RefAttributes<HTMLDivElement>>;
type MenuItemProps$2 = React.ComponentPropsWithoutRef<typeof Item$4>;
interface ContextMenuItemProps extends MenuItemProps$2 {
}
declare const ContextMenuItem: React.ForwardRefExoticComponent<ContextMenuItemProps & React.RefAttributes<HTMLDivElement>>;
type MenuCheckboxItemProps$2 = React.ComponentPropsWithoutRef<typeof CheckboxItem$3>;
interface ContextMenuCheckboxItemProps extends MenuCheckboxItemProps$2 {
}
declare const ContextMenuCheckboxItem: React.ForwardRefExoticComponent<ContextMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>>;
type MenuRadioGroupProps$2 = React.ComponentPropsWithoutRef<typeof RadioGroup$4>;
interface ContextMenuRadioGroupProps extends MenuRadioGroupProps$2 {
}
declare const ContextMenuRadioGroup: React.ForwardRefExoticComponent<ContextMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
type MenuRadioItemProps$2 = React.ComponentPropsWithoutRef<typeof RadioItem$3>;
interface ContextMenuRadioItemProps extends MenuRadioItemProps$2 {
}
declare const ContextMenuRadioItem: React.ForwardRefExoticComponent<ContextMenuRadioItemProps & React.RefAttributes<HTMLDivElement>>;
type MenuItemIndicatorProps$2 = React.ComponentPropsWithoutRef<typeof ItemIndicator$3>;
interface ContextMenuItemIndicatorProps extends MenuItemIndicatorProps$2 {
}
declare const ContextMenuItemIndicator: React.ForwardRefExoticComponent<ContextMenuItemIndicatorProps & React.RefAttributes<HTMLSpanElement>>;
type MenuSeparatorProps$2 = React.ComponentPropsWithoutRef<typeof Separator$5>;
interface ContextMenuSeparatorProps extends MenuSeparatorProps$2 {
}
declare const ContextMenuSeparator: React.ForwardRefExoticComponent<ContextMenuSeparatorProps & React.RefAttributes<HTMLDivElement>>;
type MenuArrowProps$2 = React.ComponentPropsWithoutRef<typeof Arrow$6>;
interface ContextMenuArrowProps extends MenuArrowProps$2 {
}
declare const ContextMenuArrow: React.ForwardRefExoticComponent<ContextMenuArrowProps & React.RefAttributes<SVGSVGElement>>;
interface ContextMenuSubProps {
    children?: React.ReactNode;
    open?: boolean;
    defaultOpen?: boolean;
    onOpenChange?(open: boolean): void;
}
declare const ContextMenuSub: React.FC<ContextMenuSubProps>;
type MenuSubTriggerProps$2 = React.ComponentPropsWithoutRef<typeof SubTrigger$3>;
interface ContextMenuSubTriggerProps extends MenuSubTriggerProps$2 {
}
declare const ContextMenuSubTrigger: React.ForwardRefExoticComponent<ContextMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>>;
type MenuSubContentProps$2 = React.ComponentPropsWithoutRef<typeof SubContent$3>;
interface ContextMenuSubContentProps extends MenuSubContentProps$2 {
}
declare const ContextMenuSubContent: React.ForwardRefExoticComponent<ContextMenuSubContentProps & React.RefAttributes<HTMLDivElement>>;
declare const Root$g: React.FC<ContextMenuProps>;
declare const Trigger$7: React.ForwardRefExoticComponent<ContextMenuTriggerProps & React.RefAttributes<HTMLSpanElement>>;
declare const Portal$5: React.FC<ContextMenuPortalProps>;
declare const Content$7: React.ForwardRefExoticComponent<ContextMenuContentProps & React.RefAttributes<HTMLDivElement>>;
declare const Group$2: React.ForwardRefExoticComponent<ContextMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
declare const Label$4: React.ForwardRefExoticComponent<ContextMenuLabelProps & React.RefAttributes<HTMLDivElement>>;
declare const Item$3: React.ForwardRefExoticComponent<ContextMenuItemProps & React.RefAttributes<HTMLDivElement>>;
declare const CheckboxItem$2: React.ForwardRefExoticComponent<ContextMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>>;
declare const RadioGroup$3: React.ForwardRefExoticComponent<ContextMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
declare const RadioItem$2: React.ForwardRefExoticComponent<ContextMenuRadioItemProps & React.RefAttributes<HTMLDivElement>>;
declare const ItemIndicator$2: React.ForwardRefExoticComponent<ContextMenuItemIndicatorProps & React.RefAttributes<HTMLSpanElement>>;
declare const Separator$4: React.ForwardRefExoticComponent<ContextMenuSeparatorProps & React.RefAttributes<HTMLDivElement>>;
declare const Arrow$5: React.ForwardRefExoticComponent<ContextMenuArrowProps & React.RefAttributes<SVGSVGElement>>;
declare const Sub$3: React.FC<ContextMenuSubProps>;
declare const SubTrigger$2: React.ForwardRefExoticComponent<ContextMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>>;
declare const SubContent$2: React.ForwardRefExoticComponent<ContextMenuSubContentProps & React.RefAttributes<HTMLDivElement>>;

declare const index_d$p_ContextMenu: typeof ContextMenu;
declare const index_d$p_ContextMenuArrow: typeof ContextMenuArrow;
type index_d$p_ContextMenuArrowProps = ContextMenuArrowProps;
declare const index_d$p_ContextMenuCheckboxItem: typeof ContextMenuCheckboxItem;
type index_d$p_ContextMenuCheckboxItemProps = ContextMenuCheckboxItemProps;
declare const index_d$p_ContextMenuContent: typeof ContextMenuContent;
type index_d$p_ContextMenuContentProps = ContextMenuContentProps;
declare const index_d$p_ContextMenuGroup: typeof ContextMenuGroup;
type index_d$p_ContextMenuGroupProps = ContextMenuGroupProps;
declare const index_d$p_ContextMenuItem: typeof ContextMenuItem;
declare const index_d$p_ContextMenuItemIndicator: typeof ContextMenuItemIndicator;
type index_d$p_ContextMenuItemIndicatorProps = ContextMenuItemIndicatorProps;
type index_d$p_ContextMenuItemProps = ContextMenuItemProps;
declare const index_d$p_ContextMenuLabel: typeof ContextMenuLabel;
type index_d$p_ContextMenuLabelProps = ContextMenuLabelProps;
declare const index_d$p_ContextMenuPortal: typeof ContextMenuPortal;
type index_d$p_ContextMenuPortalProps = ContextMenuPortalProps;
type index_d$p_ContextMenuProps = ContextMenuProps;
declare const index_d$p_ContextMenuRadioGroup: typeof ContextMenuRadioGroup;
type index_d$p_ContextMenuRadioGroupProps = ContextMenuRadioGroupProps;
declare const index_d$p_ContextMenuRadioItem: typeof ContextMenuRadioItem;
type index_d$p_ContextMenuRadioItemProps = ContextMenuRadioItemProps;
declare const index_d$p_ContextMenuSeparator: typeof ContextMenuSeparator;
type index_d$p_ContextMenuSeparatorProps = ContextMenuSeparatorProps;
declare const index_d$p_ContextMenuSub: typeof ContextMenuSub;
declare const index_d$p_ContextMenuSubContent: typeof ContextMenuSubContent;
type index_d$p_ContextMenuSubContentProps = ContextMenuSubContentProps;
type index_d$p_ContextMenuSubProps = ContextMenuSubProps;
declare const index_d$p_ContextMenuSubTrigger: typeof ContextMenuSubTrigger;
type index_d$p_ContextMenuSubTriggerProps = ContextMenuSubTriggerProps;
declare const index_d$p_ContextMenuTrigger: typeof ContextMenuTrigger;
type index_d$p_ContextMenuTriggerProps = ContextMenuTriggerProps;
declare const index_d$p_createContextMenuScope: typeof createContextMenuScope;
declare namespace index_d$p {
  export { Arrow$5 as Arrow, CheckboxItem$2 as CheckboxItem, Content$7 as Content, index_d$p_ContextMenu as ContextMenu, index_d$p_ContextMenuArrow as ContextMenuArrow, index_d$p_ContextMenuCheckboxItem as ContextMenuCheckboxItem, index_d$p_ContextMenuContent as ContextMenuContent, index_d$p_ContextMenuGroup as ContextMenuGroup, index_d$p_ContextMenuItem as ContextMenuItem, index_d$p_ContextMenuItemIndicator as ContextMenuItemIndicator, index_d$p_ContextMenuLabel as ContextMenuLabel, index_d$p_ContextMenuPortal as ContextMenuPortal, index_d$p_ContextMenuRadioGroup as ContextMenuRadioGroup, index_d$p_ContextMenuRadioItem as ContextMenuRadioItem, index_d$p_ContextMenuSeparator as ContextMenuSeparator, index_d$p_ContextMenuSub as ContextMenuSub, index_d$p_ContextMenuSubContent as ContextMenuSubContent, index_d$p_ContextMenuSubTrigger as ContextMenuSubTrigger, index_d$p_ContextMenuTrigger as ContextMenuTrigger, Group$2 as Group, Item$3 as Item, ItemIndicator$2 as ItemIndicator, Label$4 as Label, Portal$5 as Portal, RadioGroup$3 as RadioGroup, RadioItem$2 as RadioItem, Root$g as Root, Separator$4 as Separator, Sub$3 as Sub, SubContent$2 as SubContent, SubTrigger$2 as SubTrigger, Trigger$7 as Trigger, index_d$p_createContextMenuScope as createContextMenuScope };
  export type { index_d$p_ContextMenuArrowProps as ContextMenuArrowProps, index_d$p_ContextMenuCheckboxItemProps as ContextMenuCheckboxItemProps, index_d$p_ContextMenuContentProps as ContextMenuContentProps, index_d$p_ContextMenuGroupProps as ContextMenuGroupProps, index_d$p_ContextMenuItemIndicatorProps as ContextMenuItemIndicatorProps, index_d$p_ContextMenuItemProps as ContextMenuItemProps, index_d$p_ContextMenuLabelProps as ContextMenuLabelProps, index_d$p_ContextMenuPortalProps as ContextMenuPortalProps, index_d$p_ContextMenuProps as ContextMenuProps, index_d$p_ContextMenuRadioGroupProps as ContextMenuRadioGroupProps, index_d$p_ContextMenuRadioItemProps as ContextMenuRadioItemProps, index_d$p_ContextMenuSeparatorProps as ContextMenuSeparatorProps, index_d$p_ContextMenuSubContentProps as ContextMenuSubContentProps, index_d$p_ContextMenuSubProps as ContextMenuSubProps, index_d$p_ContextMenuSubTriggerProps as ContextMenuSubTriggerProps, index_d$p_ContextMenuTriggerProps as ContextMenuTriggerProps };
}

type Direction$5 = 'ltr' | 'rtl';
interface DirectionProviderProps {
    children?: React.ReactNode;
    dir: Direction$5;
}
declare const DirectionProvider: React.FC<DirectionProviderProps>;
declare function useDirection(localDir?: Direction$5): Direction$5;
declare const Provider$2: React.FC<DirectionProviderProps>;

declare const index_d$o_DirectionProvider: typeof DirectionProvider;
declare const index_d$o_useDirection: typeof useDirection;
declare namespace index_d$o {
  export {
    index_d$o_DirectionProvider as DirectionProvider,
    Provider$2 as Provider,
    index_d$o_useDirection as useDirection,
  };
}

type Direction$4 = 'ltr' | 'rtl';
declare const createDropdownMenuScope: CreateScope;
interface DropdownMenuProps {
    children?: React.ReactNode;
    dir?: Direction$4;
    open?: boolean;
    defaultOpen?: boolean;
    onOpenChange?(open: boolean): void;
    modal?: boolean;
}
declare const DropdownMenu: React.FC<DropdownMenuProps>;
type PrimitiveButtonProps$d = React.ComponentPropsWithoutRef<typeof Primitive.button>;
interface DropdownMenuTriggerProps extends PrimitiveButtonProps$d {
}
declare const DropdownMenuTrigger: React.ForwardRefExoticComponent<DropdownMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
type MenuPortalProps$1 = React.ComponentPropsWithoutRef<typeof Portal$6>;
interface DropdownMenuPortalProps extends MenuPortalProps$1 {
}
declare const DropdownMenuPortal: React.FC<DropdownMenuPortalProps>;
type MenuContentProps$1 = React.ComponentPropsWithoutRef<typeof Content$8>;
interface DropdownMenuContentProps extends Omit<MenuContentProps$1, 'onEntryFocus'> {
}
declare const DropdownMenuContent: React.ForwardRefExoticComponent<DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>>;
type MenuGroupProps$1 = React.ComponentPropsWithoutRef<typeof Group$3>;
interface DropdownMenuGroupProps extends MenuGroupProps$1 {
}
declare const DropdownMenuGroup: React.ForwardRefExoticComponent<DropdownMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
type MenuLabelProps$1 = React.ComponentPropsWithoutRef<typeof Label$5>;
interface DropdownMenuLabelProps extends MenuLabelProps$1 {
}
declare const DropdownMenuLabel: React.ForwardRefExoticComponent<DropdownMenuLabelProps & React.RefAttributes<HTMLDivElement>>;
type MenuItemProps$1 = React.ComponentPropsWithoutRef<typeof Item$4>;
interface DropdownMenuItemProps extends MenuItemProps$1 {
}
declare const DropdownMenuItem: React.ForwardRefExoticComponent<DropdownMenuItemProps & React.RefAttributes<HTMLDivElement>>;
type MenuCheckboxItemProps$1 = React.ComponentPropsWithoutRef<typeof CheckboxItem$3>;
interface DropdownMenuCheckboxItemProps extends MenuCheckboxItemProps$1 {
}
declare const DropdownMenuCheckboxItem: React.ForwardRefExoticComponent<DropdownMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>>;
type MenuRadioGroupProps$1 = React.ComponentPropsWithoutRef<typeof RadioGroup$4>;
interface DropdownMenuRadioGroupProps extends MenuRadioGroupProps$1 {
}
declare const DropdownMenuRadioGroup: React.ForwardRefExoticComponent<DropdownMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
type MenuRadioItemProps$1 = React.ComponentPropsWithoutRef<typeof RadioItem$3>;
interface DropdownMenuRadioItemProps extends MenuRadioItemProps$1 {
}
declare const DropdownMenuRadioItem: React.ForwardRefExoticComponent<DropdownMenuRadioItemProps & React.RefAttributes<HTMLDivElement>>;
type MenuItemIndicatorProps$1 = React.ComponentPropsWithoutRef<typeof ItemIndicator$3>;
interface DropdownMenuItemIndicatorProps extends MenuItemIndicatorProps$1 {
}
declare const DropdownMenuItemIndicator: React.ForwardRefExoticComponent<DropdownMenuItemIndicatorProps & React.RefAttributes<HTMLSpanElement>>;
type MenuSeparatorProps$1 = React.ComponentPropsWithoutRef<typeof Separator$5>;
interface DropdownMenuSeparatorProps extends MenuSeparatorProps$1 {
}
declare const DropdownMenuSeparator: React.ForwardRefExoticComponent<DropdownMenuSeparatorProps & React.RefAttributes<HTMLDivElement>>;
type MenuArrowProps$1 = React.ComponentPropsWithoutRef<typeof Arrow$6>;
interface DropdownMenuArrowProps extends MenuArrowProps$1 {
}
declare const DropdownMenuArrow: React.ForwardRefExoticComponent<DropdownMenuArrowProps & React.RefAttributes<SVGSVGElement>>;
interface DropdownMenuSubProps {
    children?: React.ReactNode;
    open?: boolean;
    defaultOpen?: boolean;
    onOpenChange?(open: boolean): void;
}
declare const DropdownMenuSub: React.FC<DropdownMenuSubProps>;
type MenuSubTriggerProps$1 = React.ComponentPropsWithoutRef<typeof SubTrigger$3>;
interface DropdownMenuSubTriggerProps extends MenuSubTriggerProps$1 {
}
declare const DropdownMenuSubTrigger: React.ForwardRefExoticComponent<DropdownMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>>;
type MenuSubContentProps$1 = React.ComponentPropsWithoutRef<typeof SubContent$3>;
interface DropdownMenuSubContentProps extends MenuSubContentProps$1 {
}
declare const DropdownMenuSubContent: React.ForwardRefExoticComponent<DropdownMenuSubContentProps & React.RefAttributes<HTMLDivElement>>;
declare const Root$f: React.FC<DropdownMenuProps>;
declare const Trigger$6: React.ForwardRefExoticComponent<DropdownMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
declare const Portal$4: React.FC<DropdownMenuPortalProps>;
declare const Content$6: React.ForwardRefExoticComponent<DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>>;
declare const Group$1: React.ForwardRefExoticComponent<DropdownMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
declare const Label$3: React.ForwardRefExoticComponent<DropdownMenuLabelProps & React.RefAttributes<HTMLDivElement>>;
declare const Item$2: React.ForwardRefExoticComponent<DropdownMenuItemProps & React.RefAttributes<HTMLDivElement>>;
declare const CheckboxItem$1: React.ForwardRefExoticComponent<DropdownMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>>;
declare const RadioGroup$2: React.ForwardRefExoticComponent<DropdownMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
declare const RadioItem$1: React.ForwardRefExoticComponent<DropdownMenuRadioItemProps & React.RefAttributes<HTMLDivElement>>;
declare const ItemIndicator$1: React.ForwardRefExoticComponent<DropdownMenuItemIndicatorProps & React.RefAttributes<HTMLSpanElement>>;
declare const Separator$3: React.ForwardRefExoticComponent<DropdownMenuSeparatorProps & React.RefAttributes<HTMLDivElement>>;
declare const Arrow$4: React.ForwardRefExoticComponent<DropdownMenuArrowProps & React.RefAttributes<SVGSVGElement>>;
declare const Sub$2: React.FC<DropdownMenuSubProps>;
declare const SubTrigger$1: React.ForwardRefExoticComponent<DropdownMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>>;
declare const SubContent$1: React.ForwardRefExoticComponent<DropdownMenuSubContentProps & React.RefAttributes<HTMLDivElement>>;

declare const index_d$n_DropdownMenu: typeof DropdownMenu;
declare const index_d$n_DropdownMenuArrow: typeof DropdownMenuArrow;
type index_d$n_DropdownMenuArrowProps = DropdownMenuArrowProps;
declare const index_d$n_DropdownMenuCheckboxItem: typeof DropdownMenuCheckboxItem;
type index_d$n_DropdownMenuCheckboxItemProps = DropdownMenuCheckboxItemProps;
declare const index_d$n_DropdownMenuContent: typeof DropdownMenuContent;
type index_d$n_DropdownMenuContentProps = DropdownMenuContentProps;
declare const index_d$n_DropdownMenuGroup: typeof DropdownMenuGroup;
type index_d$n_DropdownMenuGroupProps = DropdownMenuGroupProps;
declare const index_d$n_DropdownMenuItem: typeof DropdownMenuItem;
declare const index_d$n_DropdownMenuItemIndicator: typeof DropdownMenuItemIndicator;
type index_d$n_DropdownMenuItemIndicatorProps = DropdownMenuItemIndicatorProps;
type index_d$n_DropdownMenuItemProps = DropdownMenuItemProps;
declare const index_d$n_DropdownMenuLabel: typeof DropdownMenuLabel;
type index_d$n_DropdownMenuLabelProps = DropdownMenuLabelProps;
declare const index_d$n_DropdownMenuPortal: typeof DropdownMenuPortal;
type index_d$n_DropdownMenuPortalProps = DropdownMenuPortalProps;
type index_d$n_DropdownMenuProps = DropdownMenuProps;
declare const index_d$n_DropdownMenuRadioGroup: typeof DropdownMenuRadioGroup;
type index_d$n_DropdownMenuRadioGroupProps = DropdownMenuRadioGroupProps;
declare const index_d$n_DropdownMenuRadioItem: typeof DropdownMenuRadioItem;
type index_d$n_DropdownMenuRadioItemProps = DropdownMenuRadioItemProps;
declare const index_d$n_DropdownMenuSeparator: typeof DropdownMenuSeparator;
type index_d$n_DropdownMenuSeparatorProps = DropdownMenuSeparatorProps;
declare const index_d$n_DropdownMenuSub: typeof DropdownMenuSub;
declare const index_d$n_DropdownMenuSubContent: typeof DropdownMenuSubContent;
type index_d$n_DropdownMenuSubContentProps = DropdownMenuSubContentProps;
type index_d$n_DropdownMenuSubProps = DropdownMenuSubProps;
declare const index_d$n_DropdownMenuSubTrigger: typeof DropdownMenuSubTrigger;
type index_d$n_DropdownMenuSubTriggerProps = DropdownMenuSubTriggerProps;
declare const index_d$n_DropdownMenuTrigger: typeof DropdownMenuTrigger;
type index_d$n_DropdownMenuTriggerProps = DropdownMenuTriggerProps;
declare const index_d$n_createDropdownMenuScope: typeof createDropdownMenuScope;
declare namespace index_d$n {
  export { Arrow$4 as Arrow, CheckboxItem$1 as CheckboxItem, Content$6 as Content, index_d$n_DropdownMenu as DropdownMenu, index_d$n_DropdownMenuArrow as DropdownMenuArrow, index_d$n_DropdownMenuCheckboxItem as DropdownMenuCheckboxItem, index_d$n_DropdownMenuContent as DropdownMenuContent, index_d$n_DropdownMenuGroup as DropdownMenuGroup, index_d$n_DropdownMenuItem as DropdownMenuItem, index_d$n_DropdownMenuItemIndicator as DropdownMenuItemIndicator, index_d$n_DropdownMenuLabel as DropdownMenuLabel, index_d$n_DropdownMenuPortal as DropdownMenuPortal, index_d$n_DropdownMenuRadioGroup as DropdownMenuRadioGroup, index_d$n_DropdownMenuRadioItem as DropdownMenuRadioItem, index_d$n_DropdownMenuSeparator as DropdownMenuSeparator, index_d$n_DropdownMenuSub as DropdownMenuSub, index_d$n_DropdownMenuSubContent as DropdownMenuSubContent, index_d$n_DropdownMenuSubTrigger as DropdownMenuSubTrigger, index_d$n_DropdownMenuTrigger as DropdownMenuTrigger, Group$1 as Group, Item$2 as Item, ItemIndicator$1 as ItemIndicator, Label$3 as Label, Portal$4 as Portal, RadioGroup$2 as RadioGroup, RadioItem$1 as RadioItem, Root$f as Root, Separator$3 as Separator, Sub$2 as Sub, SubContent$1 as SubContent, SubTrigger$1 as SubTrigger, Trigger$6 as Trigger, index_d$n_createDropdownMenuScope as createDropdownMenuScope };
  export type { index_d$n_DropdownMenuArrowProps as DropdownMenuArrowProps, index_d$n_DropdownMenuCheckboxItemProps as DropdownMenuCheckboxItemProps, index_d$n_DropdownMenuContentProps as DropdownMenuContentProps, index_d$n_DropdownMenuGroupProps as DropdownMenuGroupProps, index_d$n_DropdownMenuItemIndicatorProps as DropdownMenuItemIndicatorProps, index_d$n_DropdownMenuItemProps as DropdownMenuItemProps, index_d$n_DropdownMenuLabelProps as DropdownMenuLabelProps, index_d$n_DropdownMenuPortalProps as DropdownMenuPortalProps, index_d$n_DropdownMenuProps as DropdownMenuProps, index_d$n_DropdownMenuRadioGroupProps as DropdownMenuRadioGroupProps, index_d$n_DropdownMenuRadioItemProps as DropdownMenuRadioItemProps, index_d$n_DropdownMenuSeparatorProps as DropdownMenuSeparatorProps, index_d$n_DropdownMenuSubContentProps as DropdownMenuSubContentProps, index_d$n_DropdownMenuSubProps as DropdownMenuSubProps, index_d$n_DropdownMenuSubTriggerProps as DropdownMenuSubTriggerProps, index_d$n_DropdownMenuTriggerProps as DropdownMenuTriggerProps };
}

type PrimitiveLabelProps = React.ComponentPropsWithoutRef<typeof Primitive.label>;
interface LabelProps$1 extends PrimitiveLabelProps {
}
declare const Label$2: React.ForwardRefExoticComponent<LabelProps$1 & React.RefAttributes<HTMLLabelElement>>;
declare const Root$e: React.ForwardRefExoticComponent<LabelProps$1 & React.RefAttributes<HTMLLabelElement>>;

declare namespace index_d$m {
  export { Label$2 as Label, Root$e as Root };
  export type { LabelProps$1 as LabelProps };
}

type ScopedProps$5<P> = P & {
    __scopeForm?: Scope;
};
declare const createFormScope: CreateScope;
type PrimitiveFormProps = React.ComponentPropsWithoutRef<typeof Primitive.form>;
interface FormProps extends PrimitiveFormProps {
    onClearServerErrors?(): void;
}
declare const Form: React.ForwardRefExoticComponent<FormProps & React.RefAttributes<HTMLFormElement>>;
type PrimitiveDivProps$c = React.ComponentPropsWithoutRef<typeof Primitive.div>;
interface FormFieldProps extends PrimitiveDivProps$c {
    name: string;
    serverInvalid?: boolean;
}
declare const FormField: React.ForwardRefExoticComponent<FormFieldProps & React.RefAttributes<HTMLDivElement>>;
type LabelProps = React.ComponentPropsWithoutRef<typeof Label$2>;
interface FormLabelProps extends LabelProps {
    name?: string;
}
declare const FormLabel: React.ForwardRefExoticComponent<FormLabelProps & React.RefAttributes<HTMLLabelElement>>;
type PrimitiveInputProps$2 = React.ComponentPropsWithoutRef<typeof Primitive.input>;
interface FormControlProps extends PrimitiveInputProps$2 {
}
declare const FormControl: React.ForwardRefExoticComponent<FormControlProps & React.RefAttributes<HTMLInputElement>>;
declare const _validityMatchers: readonly ["badInput", "patternMismatch", "rangeOverflow", "rangeUnderflow", "stepMismatch", "tooLong", "tooShort", "typeMismatch", "valid", "valueMissing"];
type ValidityMatcher = (typeof _validityMatchers)[number];
interface FormMessageProps extends Omit<FormMessageImplProps, 'name'> {
    match?: ValidityMatcher | CustomMatcher;
    forceMatch?: boolean;
    name?: string;
}
declare const FormMessage: React.ForwardRefExoticComponent<FormMessageProps & React.RefAttributes<HTMLSpanElement>>;
type PrimitiveSpanProps$5 = React.ComponentPropsWithoutRef<typeof Primitive.span>;
interface FormMessageImplProps extends PrimitiveSpanProps$5 {
    name: string;
}
interface FormValidityStateProps {
    children(validity: ValidityState | undefined): React.ReactNode;
    name?: string;
}
declare const FormValidityState: (props: ScopedProps$5<FormValidityStateProps>) => react_jsx_runtime.JSX.Element;
type PrimitiveButtonProps$c = React.ComponentPropsWithoutRef<typeof Primitive.button>;
interface FormSubmitProps extends PrimitiveButtonProps$c {
}
declare const FormSubmit: React.ForwardRefExoticComponent<FormSubmitProps & React.RefAttributes<HTMLButtonElement>>;
type SyncCustomMatcher = (value: string, formData: FormData) => boolean;
type AsyncCustomMatcher = (value: string, formData: FormData) => Promise<boolean>;
type CustomMatcher = SyncCustomMatcher | AsyncCustomMatcher;
declare const Root$d: React.ForwardRefExoticComponent<FormProps & React.RefAttributes<HTMLFormElement>>;
declare const Field: React.ForwardRefExoticComponent<FormFieldProps & React.RefAttributes<HTMLDivElement>>;
declare const Label$1: 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: (props: ScopedProps$5<FormValidityStateProps>) => react_jsx_runtime.JSX.Element;
declare const Submit: React.ForwardRefExoticComponent<FormSubmitProps & React.RefAttributes<HTMLButtonElement>>;

declare const index_d$l_Control: typeof Control;
declare const index_d$l_Field: typeof Field;
declare const index_d$l_Form: typeof Form;
declare const index_d$l_FormControl: typeof FormControl;
type index_d$l_FormControlProps = FormControlProps;
declare const index_d$l_FormField: typeof FormField;
type index_d$l_FormFieldProps = FormFieldProps;
declare const index_d$l_FormLabel: typeof FormLabel;
type index_d$l_FormLabelProps = FormLabelProps;
declare const index_d$l_FormMessage: typeof FormMessage;
type index_d$l_FormMessageProps = FormMessageProps;
type index_d$l_FormProps = FormProps;
declare const index_d$l_FormSubmit: typeof FormSubmit;
type index_d$l_FormSubmitProps = FormSubmitProps;
declare const index_d$l_FormValidityState: typeof FormValidityState;
type index_d$l_FormValidityStateProps = FormValidityStateProps;
declare const index_d$l_Message: typeof Message;
declare const index_d$l_Submit: typeof Submit;
declare const index_d$l_ValidityState: typeof ValidityState;
declare const index_d$l_createFormScope: typeof createFormScope;
declare namespace index_d$l {
  export { index_d$l_Control as Control, index_d$l_Field as Field, index_d$l_Form as Form, index_d$l_FormControl as FormControl, index_d$l_FormField as FormField, index_d$l_FormLabel as FormLabel, index_d$l_FormMessage as FormMessage, index_d$l_FormSubmit as FormSubmit, index_d$l_FormValidityState as FormValidityState, Label$1 as Label, index_d$l_Message as Message, Root$d as Root, index_d$l_Submit as Submit, index_d$l_ValidityState as ValidityState, index_d$l_createFormScope as createFormScope };
  export type { index_d$l_FormControlProps as FormControlProps, index_d$l_FormFieldProps as FormFieldProps, index_d$l_FormLabelProps as FormLabelProps, index_d$l_FormMessageProps as FormMessageProps, index_d$l_FormProps as FormProps, index_d$l_FormSubmitProps as FormSubmitProps, index_d$l_FormValidityStateProps as FormValidityStateProps };
}

declare const createHoverCardScope: CreateScope;
interface HoverCardProps {
    children?: React.ReactNode;
    open?: boolean;
    defaultOpen?: boolean;
    onOpenChange?: (open: boolean) => void;
    openDelay?: number;
    closeDelay?: number;
}
declare const HoverCard: React.FC<HoverCardProps>;
type PrimitiveLinkProps$2 = React.ComponentPropsWithoutRef<typeof Primitive.a>;
interface HoverCardTriggerProps extends PrimitiveLinkProps$2 {
}
declare const HoverCardTrigger: React.ForwardRefExoticComponent<HoverCardTriggerProps & React.RefAttributes<HTMLAnchorElement>>;
type PortalProps$3 = React.ComponentPropsWithoutRef<typeof Portal$8>;
interface HoverCardPortalProps {
    children?: React.ReactNode;
    /**
     * Specify a container element to portal the content into.
     */
    container?: PortalProps$3['container'];
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: true;
}
declare const HoverCardPortal: React.FC<HoverCardPortalProps>;
interface HoverCardContentProps extends HoverCardContentImplProps {
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: true;
}
declare const HoverCardContent: React.ForwardRefExoticComponent<HoverCardContentProps & React.RefAttributes<HTMLDivElement>>;
type DismissableLayerProps$5 = React.ComponentPropsWithoutRef<typeof DismissableLayer>;
type PopperContentProps$3 = React.ComponentPropsWithoutRef<typeof Content$9>;
interface HoverCardContentImplProps extends Omit<PopperContentProps$3, 'onPlaced'> {
    /**
     * Event handler called when the escape key is down.
     * Can be prevented.
     */
    onEscapeKeyDown?: DismissableLayerProps$5['onEscapeKeyDown'];
    /**
     * Event handler called when the a `pointerdown` event happens outside of the `HoverCard`.
     * Can be prevented.
     */
    onPointerDownOutside?: DismissableLayerProps$5['onPointerDownOutside'];
    /**
     * Event handler called when the focus moves outside of the `HoverCard`.
     * Can be prevented.
     */
    onFocusOutside?: DismissableLayerProps$5['onFocusOutside'];
    /**
     * Event handler called when an interaction happens outside the `HoverCard`.
     * Specifically, when a `pointerdown` event happens outside or focus moves outside of it.
     * Can be prevented.
     */
    onInteractOutside?: DismissableLayerProps$5['onInteractOutside'];
}
type PopperArrowProps$3 = React.ComponentPropsWithoutRef<typeof Arrow$7>;
interface HoverCardArrowProps extends PopperArrowProps$3 {
}
declare const HoverCardArrow: React.ForwardRefExoticComponent<HoverCardArrowProps & React.RefAttributes<SVGSVGElement>>;
declare const Root$c: React.FC<HoverCardProps>;
declare const Trigger$5: React.ForwardRefExoticComponent<HoverCardTriggerProps & React.RefAttributes<HTMLAnchorElement>>;
declare const Portal$3: React.FC<HoverCardPortalProps>;
declare const Content$5: React.ForwardRefExoticComponent<HoverCardContentProps & React.RefAttributes<HTMLDivElement>>;
declare const Arrow$3: React.ForwardRefExoticComponent<HoverCardArrowProps & React.RefAttributes<SVGSVGElement>>;

declare const index_d$k_HoverCard: typeof HoverCard;
declare const index_d$k_HoverCardArrow: typeof HoverCardArrow;
type index_d$k_HoverCardArrowProps = HoverCardArrowProps;
declare const index_d$k_HoverCardContent: typeof HoverCardContent;
type index_d$k_HoverCardContentProps = HoverCardContentProps;
declare const index_d$k_HoverCardPortal: typeof HoverCardPortal;
type index_d$k_HoverCardPortalProps = HoverCardPortalProps;
type index_d$k_HoverCardProps = HoverCardProps;
declare const index_d$k_HoverCardTrigger: typeof HoverCardTrigger;
type index_d$k_HoverCardTriggerProps = HoverCardTriggerProps;
declare const index_d$k_createHoverCardScope: typeof createHoverCardScope;
declare namespace index_d$k {
  export { Arrow$3 as Arrow, Content$5 as Content, index_d$k_HoverCard as HoverCard, index_d$k_HoverCardArrow as HoverCardArrow, index_d$k_HoverCardContent as HoverCardContent, index_d$k_HoverCardPortal as HoverCardPortal, index_d$k_HoverCardTrigger as HoverCardTrigger, Portal$3 as Portal, Root$c as Root, Trigger$5 as Trigger, index_d$k_createHoverCardScope as createHoverCardScope };
  export type { index_d$k_HoverCardArrowProps as HoverCardArrowProps, index_d$k_HoverCardContentProps as HoverCardContentProps, index_d$k_HoverCardPortalProps as HoverCardPortalProps, index_d$k_HoverCardProps as HoverCardProps, index_d$k_HoverCardTriggerProps as HoverCardTriggerProps };
}

type ScopedProps$4<P> = P & {
    __scopeMenubar?: Scope;
};
declare const createMenubarScope: CreateScope;
type RovingFocusGroupProps$5 = React.ComponentPropsWithoutRef<typeof Root$h>;
type PrimitiveDivProps$b = React.ComponentPropsWithoutRef<typeof Primitive.div>;
interface MenubarProps extends PrimitiveDivProps$b {
    value?: string;
    defaultValue?: string;
    onValueChange?: (value: string) => void;
    loop?: RovingFocusGroupProps$5['loop'];
    dir?: RovingFocusGroupProps$5['dir'];
}
declare const Menubar: React.ForwardRefExoticComponent<MenubarProps & React.RefAttributes<HTMLDivElement>>;
interface MenubarMenuProps {
    value?: string;
    children?: React.ReactNode;
}
declare const MenubarMenu: (props: ScopedProps$4<MenubarMenuProps>) => react_jsx_runtime.JSX.Element;
type PrimitiveButtonProps$b = React.ComponentPropsWithoutRef<typeof Primitive.button>;
interface MenubarTriggerProps extends PrimitiveButtonProps$b {
}
declare const MenubarTrigger: React.ForwardRefExoticComponent<MenubarTriggerProps & React.RefAttributes<HTMLButtonElement>>;
type MenuPortalProps = React.ComponentPropsWithoutRef<typeof Portal$6>;
interface MenubarPortalProps extends MenuPortalProps {
}
declare const MenubarPortal: React.FC<MenubarPortalProps>;
type MenuContentProps = React.ComponentPropsWithoutRef<typeof Content$8>;
interface MenubarContentProps extends Omit<MenuContentProps, 'onEntryFocus'> {
}
declare const MenubarContent: React.ForwardRefExoticComponent<MenubarContentProps & React.RefAttributes<HTMLDivElement>>;
type MenuGroupProps = React.ComponentPropsWithoutRef<typeof Group$3>;
interface MenubarGroupProps extends MenuGroupProps {
}
declare const MenubarGroup: React.ForwardRefExoticComponent<MenubarGroupProps & React.RefAttributes<HTMLDivElement>>;
type MenuLabelProps = React.ComponentPropsWithoutRef<typeof Label$5>;
interface MenubarLabelProps extends MenuLabelProps {
}
declare const MenubarLabel: React.ForwardRefExoticComponent<MenubarLabelProps & React.RefAttributes<HTMLDivElement>>;
type MenuItemProps = React.ComponentPropsWithoutRef<typeof Item$4>;
interface MenubarItemProps extends MenuItemProps {
}
declare const MenubarItem: React.ForwardRefExoticComponent<MenubarItemProps & React.RefAttributes<HTMLDivElement>>;
type MenuCheckboxItemProps = React.ComponentPropsWithoutRef<typeof CheckboxItem$3>;
interface MenubarCheckboxItemProps extends MenuCheckboxItemProps {
}
declare const MenubarCheckboxItem: React.ForwardRefExoticComponent<MenubarCheckboxItemProps & React.RefAttributes<HTMLDivElement>>;
type MenuRadioGroupProps = React.ComponentPropsWithoutRef<typeof RadioGroup$4>;
interface MenubarRadioGroupProps extends MenuRadioGroupProps {
}
declare const MenubarRadioGroup: React.ForwardRefExoticComponent<MenubarRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
type MenuRadioItemProps = React.ComponentPropsWithoutRef<typeof RadioItem$3>;
interface MenubarRadioItemProps extends MenuRadioItemProps {
}
declare const MenubarRadioItem: React.ForwardRefExoticComponent<MenubarRadioItemProps & React.RefAttributes<HTMLDivElement>>;
type MenuItemIndicatorProps = React.ComponentPropsWithoutRef<typeof ItemIndicator$3>;
interface MenubarItemIndicatorProps extends MenuItemIndicatorProps {
}
declare const MenubarItemIndicator: React.ForwardRefExoticComponent<MenubarItemIndicatorProps & React.RefAttributes<HTMLSpanElement>>;
type MenuSeparatorProps = React.ComponentPropsWithoutRef<typeof Separator$5>;
interface MenubarSeparatorProps extends MenuSeparatorProps {
}
declare const MenubarSeparator: React.ForwardRefExoticComponent<MenubarSeparatorProps & React.RefAttributes<HTMLDivElement>>;
type MenuArrowProps = React.ComponentPropsWithoutRef<typeof Arrow$6>;
interface MenubarArrowProps extends MenuArrowProps {
}
declare const MenubarArrow: React.ForwardRefExoticComponent<MenubarArrowProps & React.RefAttributes<SVGSVGElement>>;
interface MenubarSubProps {
    children?: React.ReactNode;
    open?: boolean;
    defaultOpen?: boolean;
    onOpenChange?(open: boolean): void;
}
declare const MenubarSub: React.FC<MenubarSubProps>;
type MenuSubTriggerProps = React.ComponentPropsWithoutRef<typeof SubTrigger$3>;
interface MenubarSubTriggerProps extends MenuSubTriggerProps {
}
declare const MenubarSubTrigger: React.ForwardRefExoticComponent<MenubarSubTriggerProps & React.RefAttributes<HTMLDivElement>>;
type MenuSubContentProps = React.ComponentPropsWithoutRef<typeof SubContent$3>;
interface MenubarSubContentProps extends MenuSubContentProps {
}
declare const MenubarSubContent: React.ForwardRefExoticComponent<MenubarSubContentProps & React.RefAttributes<HTMLDivElement>>;
declare const Root$b: React.ForwardRefExoticComponent<MenubarProps & React.RefAttributes<HTMLDivElement>>;
declare const Menu: (props: ScopedProps$4<MenubarMenuProps>) => react_jsx_runtime.JSX.Element;
declare const Trigger$4: React.ForwardRefExoticComponent<MenubarTriggerProps & React.RefAttributes<HTMLButtonElement>>;
declare const Portal$2: React.FC<MenubarPortalProps>;
declare const Content$4: React.ForwardRefExoticComponent<MenubarContentProps & React.RefAttributes<HTMLDivElement>>;
declare const Group: React.ForwardRefExoticComponent<MenubarGroupProps & React.RefAttributes<HTMLDivElement>>;
declare const Label: React.ForwardRefExoticComponent<MenubarLabelProps & React.RefAttributes<HTMLDivElement>>;
declare const Item$1: React.ForwardRefExoticComponent<MenubarItemProps & React.RefAttributes<HTMLDivElement>>;
declare const CheckboxItem: React.ForwardRefExoticComponent<MenubarCheckboxItemProps & React.RefAttributes<HTMLDivElement>>;
declare const RadioGroup$1: React.ForwardRefExoticComponent<MenubarRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
declare const RadioItem: React.ForwardRefExoticComponent<MenubarRadioItemProps & React.RefAttributes<HTMLDivElement>>;
declare const ItemIndicator: React.ForwardRefExoticComponent<MenubarItemIndicatorProps & React.RefAttributes<HTMLSpanElement>>;
declare const Separator$2: React.ForwardRefExoticComponent<MenubarSeparatorProps & React.RefAttributes<HTMLDivElement>>;
declare const Arrow$2: React.ForwardRefExoticComponent<MenubarArrowProps & React.RefAttributes<SVGSVGElement>>;
declare const Sub$1: React.FC<MenubarSubProps>;
declare const SubTrigger: React.ForwardRefExoticComponent<MenubarSubTriggerProps & React.RefAttributes<HTMLDivElement>>;
declare const SubContent: React.ForwardRefExoticComponent<MenubarSubContentProps & React.RefAttributes<HTMLDivElement>>;

declare const index_d$j_CheckboxItem: typeof CheckboxItem;
declare const index_d$j_Group: typeof Group;
declare const index_d$j_ItemIndicator: typeof ItemIndicator;
declare const index_d$j_Label: typeof Label;
declare const index_d$j_Menu: typeof Menu;
declare const index_d$j_Menubar: typeof Menubar;
declare const index_d$j_MenubarArrow: typeof MenubarArrow;
type index_d$j_MenubarArrowProps = MenubarArrowProps;
declare const index_d$j_MenubarCheckboxItem: typeof MenubarCheckboxItem;
type index_d$j_MenubarCheckboxItemProps = MenubarCheckboxItemProps;
declare const index_d$j_MenubarContent: typeof MenubarContent;
type index_d$j_MenubarContentProps = MenubarContentProps;
declare const index_d$j_MenubarGroup: typeof MenubarGroup;
type index_d$j_MenubarGroupProps = MenubarGroupProps;
declare const index_d$j_MenubarItem: typeof MenubarItem;
declare const index_d$j_MenubarItemIndicator: typeof MenubarItemIndicator;
type index_d$j_MenubarItemIndicatorProps = MenubarItemIndicatorProps;
type index_d$j_MenubarItemProps = MenubarItemProps;
declare const index_d$j_MenubarLabel: typeof MenubarLabel;
type index_d$j_MenubarLabelProps = MenubarLabelProps;
declare const index_d$j_MenubarMenu: typeof MenubarMenu;
type index_d$j_MenubarMenuProps = MenubarMenuProps;
declare const index_d$j_MenubarPortal: typeof MenubarPortal;
type index_d$j_MenubarPortalProps = MenubarPortalProps;
type index_d$j_MenubarProps = MenubarProps;
declare const index_d$j_MenubarRadioGroup: typeof MenubarRadioGroup;
type index_d$j_MenubarRadioGroupProps = MenubarRadioGroupProps;
declare const index_d$j_MenubarRadioItem: typeof MenubarRadioItem;
type index_d$j_MenubarRadioItemProps = MenubarRadioItemProps;
declare const index_d$j_MenubarSeparator: typeof MenubarSeparator;
type index_d$j_MenubarSeparatorProps = MenubarSeparatorProps;
declare const index_d$j_MenubarSub: typeof MenubarSub;
declare const index_d$j_MenubarSubContent: typeof MenubarSubContent;
type index_d$j_MenubarSubContentProps = MenubarSubContentProps;
type index_d$j_MenubarSubProps = MenubarSubProps;
declare const index_d$j_MenubarSubTrigger: typeof MenubarSubTrigger;
type index_d$j_MenubarSubTriggerProps = MenubarSubTriggerProps;
declare const index_d$j_MenubarTrigger: typeof MenubarTrigger;
type index_d$j_MenubarTriggerProps = MenubarTriggerProps;
declare const index_d$j_RadioItem: typeof RadioItem;
declare const index_d$j_SubContent: typeof SubContent;
declare const index_d$j_SubTrigger: typeof SubTrigger;
declare const index_d$j_createMenubarScope: typeof createMenubarScope;
declare namespace index_d$j {
  export { Arrow$2 as Arrow, index_d$j_CheckboxItem as CheckboxItem, Content$4 as Content, index_d$j_Group as Group, Item$1 as Item, index_d$j_ItemIndicator as ItemIndicator, index_d$j_Label as Label, index_d$j_Menu as Menu, index_d$j_Menubar as Menubar, index_d$j_MenubarArrow as MenubarArrow, index_d$j_MenubarCheckboxItem as MenubarCheckboxItem, index_d$j_MenubarContent as MenubarContent, index_d$j_MenubarGroup as MenubarGroup, index_d$j_MenubarItem as MenubarItem, index_d$j_MenubarItemIndicator as MenubarItemIndicator, index_d$j_MenubarLabel as MenubarLabel, index_d$j_MenubarMenu as MenubarMenu, index_d$j_MenubarPortal as MenubarPortal, index_d$j_MenubarRadioGroup as MenubarRadioGroup, index_d$j_MenubarRadioItem as MenubarRadioItem, index_d$j_MenubarSeparator as MenubarSeparator, index_d$j_MenubarSub as MenubarSub, index_d$j_MenubarSubContent as MenubarSubContent, index_d$j_MenubarSubTrigger as MenubarSubTrigger, index_d$j_MenubarTrigger as MenubarTrigger, Portal$2 as Portal, RadioGroup$1 as RadioGroup, index_d$j_RadioItem as RadioItem, Root$b as Root, Separator$2 as Separator, Sub$1 as Sub, index_d$j_SubContent as SubContent, index_d$j_SubTrigger as SubTrigger, Trigger$4 as Trigger, index_d$j_createMenubarScope as createMenubarScope };
  export type { index_d$j_MenubarArrowProps as MenubarArrowProps, index_d$j_MenubarCheckboxItemProps as MenubarCheckboxItemProps, index_d$j_MenubarContentProps as MenubarContentProps, index_d$j_MenubarGroupProps as MenubarGroupProps, index_d$j_MenubarItemIndicatorProps as MenubarItemIndicatorProps, index_d$j_MenubarItemProps as MenubarItemProps, index_d$j_MenubarLabelProps as MenubarLabelProps, index_d$j_MenubarMenuProps as MenubarMenuProps, index_d$j_MenubarPortalProps as MenubarPortalProps, index_d$j_MenubarProps as MenubarProps, index_d$j_MenubarRadioGroupProps as MenubarRadioGroupProps, index_d$j_MenubarRadioItemProps as MenubarRadioItemProps, index_d$j_MenubarSeparatorProps as MenubarSeparatorProps, index_d$j_MenubarSubContentProps as MenubarSubContentProps, index_d$j_MenubarSubProps as MenubarSubProps, index_d$j_MenubarSubTriggerProps as MenubarSubTriggerProps, index_d$j_MenubarTriggerProps as MenubarTriggerProps };
}

declare const VISUALLY_HIDDEN_STYLES: Readonly<{
    position: "absolute";
    border: 0;
    width: 1;
    height: 1;
    padding: 0;
    margin: -1;
    overflow: "hidden";
    clip: "rect(0, 0, 0, 0)";
    whiteSpace: "nowrap";
    wordWrap: "normal";
}>;
type PrimitiveSpanProps$4 = React.ComponentPropsWithoutRef<typeof Primitive.span>;
interface VisuallyHiddenProps extends PrimitiveSpanProps$4 {
}
declare const VisuallyHidden: React.ForwardRefExoticComponent<VisuallyHiddenProps & React.RefAttributes<HTMLSpanElement>>;
declare const Root$a: React.ForwardRefExoticComponent<VisuallyHiddenProps & React.RefAttributes<HTMLSpanElement>>;

declare const index_d$i_VISUALLY_HIDDEN_STYLES: typeof VISUALLY_HIDDEN_STYLES;
declare const index_d$i_VisuallyHidden: typeof VisuallyHidden;
type index_d$i_VisuallyHiddenProps = VisuallyHiddenProps;
declare namespace index_d$i {
  export { Root$a as Root, index_d$i_VISUALLY_HIDDEN_STYLES as VISUALLY_HIDDEN_STYLES, index_d$i_VisuallyHidden as VisuallyHidden };
  export type { index_d$i_VisuallyHiddenProps as VisuallyHiddenProps };
}

type Orientation$1 = 'vertical' | 'horizontal';
type Direction$3 = 'ltr' | 'rtl';
declare const createNavigationMenuScope: CreateScope;
type NavigationMenuElement = React.ComponentRef<typeof Primitive.nav>;
type PrimitiveNavProps = React.ComponentPropsWithoutRef<typeof Primitive.nav>;
interface NavigationMenuProps extends Omit<NavigationMenuProviderProps, keyof NavigationMenuProviderPrivateProps>, PrimitiveNavProps {
    value?: string;
    defaultValue?: string;
    onValueChange?: (value: string) => void;
    dir?: Direction$3;
    orientation?: Orientation$1;
    /**
     * The duration from when the pointer enters the trigger until the tooltip gets opened.
     * @defaultValue 200
     */
    delayDuration?: number;
    /**
     * How much time a user has to enter another trigger without incurring a delay again.
     * @defaultValue 300
     */
    skipDelayDuration?: number;
}
declare const NavigationMenu: React.ForwardRefExoticComponent<NavigationMenuProps & React.RefAttributes<HTMLElement>>;
type PrimitiveDivProps$a = React.ComponentPropsWithoutRef<typeof Primitive.div>;
interface NavigationMenuSubProps extends Omit<NavigationMenuProviderProps, keyof NavigationMenuProviderPrivateProps>, PrimitiveDivProps$a {
    value?: string;
    defaultValue?: string;
    onValueChange?: (value: string) => void;
    orientation?: Orientation$1;
}
declare const NavigationMenuSub: React.ForwardRefExoticComponent<NavigationMenuSubProps & React.RefAttributes<HTMLDivElement>>;
interface NavigationMenuProviderPrivateProps {
    isRootMenu: boolean;
    scope: Scope;
    children: React.ReactNode;
    orientation: Orientation$1;
    dir: Direction$3;
    rootNavigationMenu: NavigationMenuElement | null;
    value: string;
    onTriggerEnter(itemValue: string): void;
    onTriggerLeave?(): void;
    onContentEnter?(): void;
    onContentLeave?(): void;
    onItemSelect(itemValue: string): void;
    onItemDismiss(): void;
}
interface NavigationMenuProviderProps extends NavigationMenuProviderPrivateProps {
}
type PrimitiveUnorderedListProps = React.ComponentPropsWithoutRef<typeof Primitive.ul>;
interface NavigationMenuListProps extends PrimitiveUnorderedListProps {
}
declare const NavigationMenuList: React.ForwardRefExoticComponent<NavigationMenuListProps & React.RefAttributes<HTMLUListElement>>;
type FocusProxyElement = React.ComponentRef<typeof Root$a>;
type PrimitiveListItemProps$1 = React.ComponentPropsWithoutRef<typeof Primitive.li>;
interface NavigationMenuItemProps extends PrimitiveListItemProps$1 {
    value?: string;
}
declare const NavigationMenuItem: React.ForwardRefExoticComponent<NavigationMenuItemProps & React.RefAttributes<HTMLLIElement>>;
type NavigationMenuTriggerElement = React.ComponentRef<typeof Primitive.button>;
type PrimitiveButtonProps$a = React.ComponentPropsWithoutRef<typeof Primitive.button>;
interface NavigationMenuTriggerProps extends PrimitiveButtonProps$a {
}
declare const NavigationMenuTrigger: React.ForwardRefExoticComponent<NavigationMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
type PrimitiveLinkProps$1 = React.ComponentPropsWithoutRef<typeof Primitive.a>;
interface NavigationMenuLinkProps extends Omit<PrimitiveLinkProps$1, 'onSelect'> {
    active?: boolean;
    onSelect?: (event: Event) => void;
}
declare const NavigationMenuLink: React.ForwardRefExoticComponent<NavigationMenuLinkProps & React.RefAttributes<HTMLAnchorElement>>;
interface NavigationMenuIndicatorProps extends NavigationMenuIndicatorImplProps {
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: true;
}
declare const NavigationMenuIndicator: React.ForwardRefExoticComponent<NavigationMenuIndicatorProps & React.RefAttributes<HTMLDivElement>>;
interface NavigationMenuIndicatorImplProps extends PrimitiveDivProps$a {
}
interface NavigationMenuContentProps extends Omit<NavigationMenuContentImplProps, keyof NavigationMenuContentImplPrivateProps> {
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: true;
}
declare const NavigationMenuContent: React.ForwardRefExoticComponent<NavigationMenuContentProps & React.RefAttributes<HTMLDivElement>>;
type DismissableLayerProps$4 = React.ComponentPropsWithoutRef<typeof DismissableLayer>;
interface NavigationMenuContentImplPrivateProps {
    value: string;
    triggerRef: React.RefObject<NavigationMenuTriggerElement | null>;
    focusProxyRef: React.RefObject<FocusProxyElement | null>;
    wasEscapeCloseRef: React.MutableRefObject<boolean>;
    onContentFocusOutside(): void;
    onRootContentClose(): void;
}
interface NavigationMenuContentImplProps extends Omit<DismissableLayerProps$4, 'onDismiss' | 'disableOutsidePointerEvents'>, NavigationMenuContentImplPrivateProps {
}
interface NavigationMenuViewportProps extends Omit<NavigationMenuViewportImplProps, 'activeContentValue'> {
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: true;
}
declare const NavigationMenuViewport: React.ForwardRefExoticComponent<NavigationMenuViewportProps & React.RefAttributes<HTMLDivElement>>;
interface NavigationMenuViewportImplProps extends PrimitiveDivProps$a {
}
declare const Root$9: React.ForwardRefExoticComponent<NavigationMenuProps & React.RefAttributes<HTMLElement>>;
declare const Sub: React.ForwardRefExoticComponent<NavigationMenuSubProps & React.RefAttributes<HTMLDivElement>>;
declare const List$1: React.ForwardRefExoticComponent<NavigationMenuListProps & React.RefAttributes<HTMLUListElement>>;
declare const Item: React.ForwardRefExoticComponent<NavigationMenuItemProps & React.RefAttributes<HTMLLIElement>>;
declare const Trigger$3: React.ForwardRefExoticComponent<NavigationMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
declare const Link$1: React.ForwardRefExoticComponent<NavigationMenuLinkProps & React.RefAttributes<HTMLAnchorElement>>;
declare const Indicator$1: React.ForwardRefExoticComponent<NavigationMenuIndicatorProps & React.RefAttributes<HTMLDivElement>>;
declare const Content$3: React.ForwardRefExoticComponent<NavigationMenuContentProps & React.RefAttributes<HTMLDivElement>>;
declare const Viewport$2: React.ForwardRefExoticComponent<NavigationMenuViewportProps & React.RefAttributes<HTMLDivElement>>;

declare const index_d$h_Item: typeof Item;
declare const index_d$h_NavigationMenu: typeof NavigationMenu;
declare const index_d$h_NavigationMenuContent: typeof NavigationMenuContent;
type index_d$h_NavigationMenuContentProps = NavigationMenuContentProps;
declare const index_d$h_NavigationMenuIndicator: typeof NavigationMenuIndicator;
type index_d$h_NavigationMenuIndicatorProps = NavigationMenuIndicatorProps;
declare const index_d$h_NavigationMenuItem: typeof NavigationMenuItem;
type index_d$h_NavigationMenuItemProps = NavigationMenuItemProps;
declare const index_d$h_NavigationMenuLink: typeof NavigationMenuLink;
type index_d$h_NavigationMenuLinkProps = NavigationMenuLinkProps;
declare const index_d$h_NavigationMenuList: typeof NavigationMenuList;
type index_d$h_NavigationMenuListProps = NavigationMenuListProps;
type index_d$h_NavigationMenuProps = NavigationMenuProps;
declare const index_d$h_NavigationMenuSub: typeof NavigationMenuSub;
type index_d$h_NavigationMenuSubProps = NavigationMenuSubProps;
declare const index_d$h_NavigationMenuTrigger: typeof NavigationMenuTrigger;
type index_d$h_NavigationMenuTriggerProps = NavigationMenuTriggerProps;
declare const index_d$h_NavigationMenuViewport: typeof NavigationMenuViewport;
type index_d$h_NavigationMenuViewportProps = NavigationMenuViewportProps;
declare const index_d$h_Sub: typeof Sub;
declare const index_d$h_createNavigationMenuScope: typeof createNavigationMenuScope;
declare namespace index_d$h {
  export { Content$3 as Content, Indicator$1 as Indicator, index_d$h_Item as Item, Link$1 as Link, List$1 as List, index_d$h_NavigationMenu as NavigationMenu, index_d$h_NavigationMenuContent as NavigationMenuContent, index_d$h_NavigationMenuIndicator as NavigationMenuIndicator, index_d$h_NavigationMenuItem as NavigationMenuItem, index_d$h_NavigationMenuLink as NavigationMenuLink, index_d$h_NavigationMenuList as NavigationMenuList, index_d$h_NavigationMenuSub as NavigationMenuSub, index_d$h_NavigationMenuTrigger as NavigationMenuTrigger, index_d$h_NavigationMenuViewport as NavigationMenuViewport, Root$9 as Root, index_d$h_Sub as Sub, Trigger$3 as Trigger, Viewport$2 as Viewport, index_d$h_createNavigationMenuScope as createNavigationMenuScope };
  export type { index_d$h_NavigationMenuContentProps as NavigationMenuContentProps, index_d$h_NavigationMenuIndicatorProps as NavigationMenuIndicatorProps, index_d$h_NavigationMenuItemProps as NavigationMenuItemProps, index_d$h_NavigationMenuLinkProps as NavigationMenuLinkProps, index_d$h_NavigationMenuListProps as NavigationMenuListProps, index_d$h_NavigationMenuProps as NavigationMenuProps, index_d$h_NavigationMenuSubProps as NavigationMenuSubProps, index_d$h_NavigationMenuTriggerProps as NavigationMenuTriggerProps, index_d$h_NavigationMenuViewportProps as NavigationMenuViewportProps };
}

type InputValidationType = 'alpha' | 'numeric' | 'alphanumeric' | 'none';
type RovingFocusGroupProps$4 = RovingFocusGroupProps$7;
interface OneTimePasswordFieldOwnProps {
    /**
     * Specifies what—if any—permission the user agent has to provide automated
     * assistance in filling out form field values, as well as guidance to the
     * browser as to the type of information expected in the field. Allows
     * `"one-time-code"` or `"off"`.
     *
     * @defaultValue `"one-time-code"`
     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Attributes/autocomplete
     */
    autoComplete?: AutoComplete;
    /**
     * Whether or not the first fillable input should be focused on page-load.
     *
     * @defaultValue `false`
     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Global_attributes/autofocus
     */
    autoFocus?: boolean;
    /**
     * Whether or not the component should attempt to automatically submit when
     * all fields are filled. If the field is associated with an HTML `form`
     * element, the form's `requestSubmit` method will be called.
     *
     * @defaultValue `false`
     */
    autoSubmit?: boolean;
    /**
     * The initial value of the uncontrolled field.
     */
    defaultValue?: string;
    /**
     * Indicates the horizontal directionality of the parent element's text.
     *
     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Global_attributes/dir
     */
    dir?: RovingFocusGroupProps$4['dir'];
    /**
     * Whether or not the the field's input elements are disabled.
     */
    disabled?: boolean;
    /**
     * A string specifying the `form` element with which the input is associated.
     * This string's value, if present, must match the id of a `form` element in
     * the same document.
     *
     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/input#form
     */
    form?: string | undefined;
    /**
     * A string specifying a name for the input control. This name is submitted
     * along with the control's value when the form data is submitted.
     *
     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/input#name
     */
    name?: string | undefined;
    /**
     * When the `autoSubmit` prop is set to `true`, this callback will be fired
     * before attempting to submit the associated form. It will be called whether
     * or not a form is located, or if submission is not allowed.
     */
    onAutoSubmit?: (value: string) => void;
    /**
     * A callback fired when the field's value changes. When the component is
     * controlled, this should update the state passed to the `value` prop.
     */
    onValueChange?: (value: string) => void;
    /**
     * Indicates the vertical directionality of the input elements.
     *
     * @defaultValue `"horizontal"`
     */
    orientation?: RovingFocusGroupProps$4['orientation'];
    /**
     * Defines the text displayed in a form control when the control has no value.
     *
     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Attributes/placeholder
     */
    placeholder?: string | undefined;
    /**
     * Whether or not the input elements can be updated by the user.
     *
     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Attributes/readonly
     */
    readOnly?: boolean;
    /**
     * Function for custom sanitization when `validationType` is set to `"none"`.
     * This function will be called before updating values in response to user
     * interactions.
     */
    sanitizeValue?: (value: string) => string;
    /**
     * The input type of the field's input elements. Can be `"password"` or `"text"`.
     */
    type?: InputType;
    /**
     * Specifies the type of input validation to be used. Can be `"alpha"`,
     * `"numeric"`, `"alphanumeric"` or `"none"`.
     *
     * @defaultValue `"numeric"`
     */
    validationType?: InputValidationType;
    /**
     * The controlled value of the field.
     */
    value?: string;
}
interface OneTimePasswordFieldProps extends OneTimePasswordFieldOwnProps, Omit<PrimitivePropsWithRef<'div'>, keyof OneTimePasswordFieldOwnProps> {
}
declare const OneTimePasswordField: React.ForwardRefExoticComponent<Omit<OneTimePasswordFieldProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
interface OneTimePasswordFieldHiddenInputProps extends Omit<React.ComponentProps<'input'>, keyof 'value' | 'defaultValue' | 'type' | 'onChange' | 'readOnly' | 'disabled' | 'autoComplete' | 'autoFocus'> {
}
declare const OneTimePasswordFieldHiddenInput: React.ForwardRefExoticComponent<Omit<OneTimePasswordFieldHiddenInputProps, "ref"> & React.RefAttributes<HTMLInputElement>>;
interface OneTimePasswordFieldInputProps extends Omit<PrimitivePropsWithRef<'input'>, 'value' | 'defaultValue' | 'disabled' | 'readOnly' | 'autoComplete' | 'autoFocus' | 'form' | 'name' | 'placeholder' | 'type'> {
    /**
     * Callback fired when the user input fails native HTML input validation.
     */
    onInvalidChange?: (character: string) => void;
    /**
     * User-provided index to determine the order of the inputs. This is useful if
     * you need certain index-based attributes to be set on the initial render,
     * often to prevent flickering after hydration.
     */
    index?: number;
}
declare const OneTimePasswordFieldInput: React.ForwardRefExoticComponent<Omit<OneTimePasswordFieldInputProps, "ref"> & React.RefAttributes<HTMLInputElement>>;

type InputType = 'password' | 'text';
type AutoComplete = 'off' | 'one-time-code';

type index_d$g_InputValidationType = InputValidationType;
declare const index_d$g_OneTimePasswordField: typeof OneTimePasswordField;
declare const index_d$g_OneTimePasswordFieldHiddenInput: typeof OneTimePasswordFieldHiddenInput;
type index_d$g_OneTimePasswordFieldHiddenInputProps = OneTimePasswordFieldHiddenInputProps;
declare const index_d$g_OneTimePasswordFieldInput: typeof OneTimePasswordFieldInput;
type index_d$g_OneTimePasswordFieldInputProps = OneTimePasswordFieldInputProps;
type index_d$g_OneTimePasswordFieldProps = OneTimePasswordFieldProps;
declare namespace index_d$g {
  export { OneTimePasswordFieldHiddenInput as HiddenInput, OneTimePasswordFieldInput as Input, index_d$g_OneTimePasswordField as OneTimePasswordField, index_d$g_OneTimePasswordFieldHiddenInput as OneTimePasswordFieldHiddenInput, index_d$g_OneTimePasswordFieldInput as OneTimePasswordFieldInput, OneTimePasswordField as Root };
  export type { index_d$g_InputValidationType as InputValidationType, index_d$g_OneTimePasswordFieldHiddenInputProps as OneTimePasswordFieldHiddenInputProps, index_d$g_OneTimePasswordFieldInputProps as OneTimePasswordFieldInputProps, index_d$g_OneTimePasswordFieldProps as OneTimePasswordFieldProps };
}

interface PasswordToggleFieldProps {
    id?: string;
    visible?: boolean;
    defaultVisible?: boolean;
    onVisibilityChange?: (visible: boolean) => void;
    children?: React.ReactNode;
}
declare const PasswordToggleField: React.FC<PasswordToggleFieldProps>;
type PrimitiveInputProps$1 = PrimitivePropsWithRef<'input'>;
interface PasswordToggleFieldOwnProps {
    autoComplete?: 'current-password' | 'new-password';
}
interface PasswordToggleFieldInputProps extends PasswordToggleFieldOwnProps, Omit<PrimitiveInputProps$1, keyof PasswordToggleFieldOwnProps | 'type'> {
    autoComplete?: 'current-password' | 'new-password';
}
declare const PasswordToggleFieldInput: React.ForwardRefExoticComponent<Omit<PasswordToggleFieldInputProps, "ref"> & React.RefAttributes<HTMLInputElement>>;
type PrimitiveButtonProps$9 = PrimitivePropsWithRef<'button'>;
interface PasswordToggleFieldToggleProps extends Omit<PrimitiveButtonProps$9, 'type'> {
}
declare const PasswordToggleFieldToggle: React.ForwardRefExoticComponent<Omit<PasswordToggleFieldToggleProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
interface PasswordToggleFieldSlotDeclarativeProps {
    visible: React.ReactNode;
    hidden: React.ReactNode;
}
interface PasswordToggleFieldSlotRenderProps {
    render: (args: {
        visible: boolean;
    }) => React.ReactElement;
}
type PasswordToggleFieldSlotProps = PasswordToggleFieldSlotDeclarativeProps | PasswordToggleFieldSlotRenderProps;
declare const PasswordToggleFieldSlot: React.FC<PasswordToggleFieldSlotProps>;
type PrimitiveSvgProps = PrimitivePropsWithRef<'svg'>;
interface PasswordToggleFieldIconProps extends Omit<PrimitiveSvgProps, 'children'> {
    visible: React.ReactElement;
    hidden: React.ReactElement;
}
declare const PasswordToggleFieldIcon: React.ForwardRefExoticComponent<Omit<PasswordToggleFieldIconProps, "ref"> & React.RefAttributes<SVGSVGElement>>;

declare const index_d$f_PasswordToggleField: typeof PasswordToggleField;
declare const index_d$f_PasswordToggleFieldIcon: typeof PasswordToggleFieldIcon;
type index_d$f_PasswordToggleFieldIconProps = PasswordToggleFieldIconProps;
declare const index_d$f_PasswordToggleFieldInput: typeof PasswordToggleFieldInput;
type index_d$f_PasswordToggleFieldInputProps = PasswordToggleFieldInputProps;
type index_d$f_PasswordToggleFieldProps = PasswordToggleFieldProps;
declare const index_d$f_PasswordToggleFieldSlot: typeof PasswordToggleFieldSlot;
type index_d$f_PasswordToggleFieldSlotProps = PasswordToggleFieldSlotProps;
declare const index_d$f_PasswordToggleFieldToggle: typeof PasswordToggleFieldToggle;
type index_d$f_PasswordToggleFieldToggleProps = PasswordToggleFieldToggleProps;
declare namespace index_d$f {
  export { PasswordToggleFieldIcon as Icon, PasswordToggleFieldInput as Input, index_d$f_PasswordToggleField as PasswordToggleField, index_d$f_PasswordToggleFieldIcon as PasswordToggleFieldIcon, index_d$f_PasswordToggleFieldInput as PasswordToggleFieldInput, index_d$f_PasswordToggleFieldSlot as PasswordToggleFieldSlot, index_d$f_PasswordToggleFieldToggle as PasswordToggleFieldToggle, PasswordToggleField as Root, PasswordToggleFieldSlot as Slot, PasswordToggleFieldToggle as Toggle };
  export type { index_d$f_PasswordToggleFieldIconProps as PasswordToggleFieldIconProps, index_d$f_PasswordToggleFieldInputProps as PasswordToggleFieldInputProps, index_d$f_PasswordToggleFieldProps as PasswordToggleFieldProps, index_d$f_PasswordToggleFieldSlotProps as PasswordToggleFieldSlotProps, index_d$f_PasswordToggleFieldToggleProps as PasswordToggleFieldToggleProps };
}

declare const createPopoverScope: CreateScope;
interface PopoverProps {
    children?: React.ReactNode;
    open?: boolean;
    defaultOpen?: boolean;
    onOpenChange?: (open: boolean) => void;
    modal?: boolean;
}
declare const Popover: React.FC<PopoverProps>;
type PopperAnchorProps = React.ComponentPropsWithoutRef<typeof Anchor$1>;
interface PopoverAnchorProps extends PopperAnchorProps {
}
declare const PopoverAnchor: React.ForwardRefExoticComponent<PopoverAnchorProps & React.RefAttributes<HTMLDivElement>>;
type PrimitiveButtonProps$8 = React.ComponentPropsWithoutRef<typeof Primitive.button>;
interface PopoverTriggerProps extends PrimitiveButtonProps$8 {
}
declare const PopoverTrigger: React.ForwardRefExoticComponent<PopoverTriggerProps & React.RefAttributes<HTMLButtonElement>>;
type PortalProps$2 = React.ComponentPropsWithoutRef<typeof Portal$8>;
interface PopoverPortalProps {
    children?: React.ReactNode;
    /**
     * Specify a container element to portal the content into.
     */
    container?: PortalProps$2['container'];
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: true;
}
declare const PopoverPortal: React.FC<PopoverPortalProps>;
interface PopoverContentProps extends PopoverContentTypeProps {
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: true;
}
declare const PopoverContent: React.ForwardRefExoticComponent<PopoverContentProps & React.RefAttributes<HTMLDivElement>>;
interface PopoverContentTypeProps extends Omit<PopoverContentImplProps, 'trapFocus' | 'disableOutsidePointerEvents'> {
}
type FocusScopeProps$1 = React.ComponentPropsWithoutRef<typeof FocusScope>;
type DismissableLayerProps$3 = React.ComponentPropsWithoutRef<typeof DismissableLayer>;
type PopperContentProps$2 = React.ComponentPropsWithoutRef<typeof Content$9>;
interface PopoverContentImplProps extends Omit<PopperContentProps$2, 'onPlaced'>, Omit<DismissableLayerProps$3, 'onDismiss'> {
    /**
     * Whether focus should be trapped within the `Popover`
     * (default: false)
     */
    trapFocus?: FocusScopeProps$1['trapped'];
    /**
     * Event handler called when auto-focusing on open.
     * Can be prevented.
     */
    onOpenAutoFocus?: FocusScopeProps$1['onMountAutoFocus'];
    /**
     * Event handler called when auto-focusing on close.
     * Can be prevented.
     */
    onCloseAutoFocus?: FocusScopeProps$1['onUnmountAutoFocus'];
}
interface PopoverCloseProps extends PrimitiveButtonProps$8 {
}
declare const PopoverClose: React.ForwardRefExoticComponent<PopoverCloseProps & React.RefAttributes<HTMLButtonElement>>;
type PopperArrowProps$2 = React.ComponentPropsWithoutRef<typeof Arrow$7>;
interface PopoverArrowProps extends PopperArrowProps$2 {
}
declare const PopoverArrow: React.ForwardRefExoticComponent<PopoverArrowProps & React.RefAttributes<SVGSVGElement>>;
declare const Root$8: React.FC<PopoverProps>;
declare const Anchor: React.ForwardRefExoticComponent<PopoverAnchorProps & React.RefAttributes<HTMLDivElement>>;
declare const Trigger$2: 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 Close$1: React.ForwardRefExoticComponent<PopoverCloseProps & React.RefAttributes<HTMLButtonElement>>;
declare const Arrow$1: React.ForwardRefExoticComponent<PopoverArrowProps & React.RefAttributes<SVGSVGElement>>;

declare const index_d$e_Anchor: typeof Anchor;
declare const index_d$e_Popover: typeof Popover;
declare const index_d$e_PopoverAnchor: typeof PopoverAnchor;
type index_d$e_PopoverAnchorProps = PopoverAnchorProps;
declare const index_d$e_PopoverArrow: typeof PopoverArrow;
type index_d$e_PopoverArrowProps = PopoverArrowProps;
declare const index_d$e_PopoverClose: typeof PopoverClose;
type index_d$e_PopoverCloseProps = PopoverCloseProps;
declare const index_d$e_PopoverContent: typeof PopoverContent;
type index_d$e_PopoverContentProps = PopoverContentProps;
declare const index_d$e_PopoverPortal: typeof PopoverPortal;
type index_d$e_PopoverPortalProps = PopoverPortalProps;
type index_d$e_PopoverProps = PopoverProps;
declare const index_d$e_PopoverTrigger: typeof PopoverTrigger;
type index_d$e_PopoverTriggerProps = PopoverTriggerProps;
declare const index_d$e_createPopoverScope: typeof createPopoverScope;
declare namespace index_d$e {
  export { index_d$e_Anchor as Anchor, Arrow$1 as Arrow, Close$1 as Close, Content$2 as Content, index_d$e_Popover as Popover, index_d$e_PopoverAnchor as PopoverAnchor, index_d$e_PopoverArrow as PopoverArrow, index_d$e_PopoverClose as PopoverClose, index_d$e_PopoverContent as PopoverContent, index_d$e_PopoverPortal as PopoverPortal, index_d$e_PopoverTrigger as PopoverTrigger, Portal$1 as Portal, Root$8 as Root, Trigger$2 as Trigger, index_d$e_createPopoverScope as createPopoverScope };
  export type { index_d$e_PopoverAnchorProps as PopoverAnchorProps, index_d$e_PopoverArrowProps as PopoverArrowProps, index_d$e_PopoverCloseProps as PopoverCloseProps, index_d$e_PopoverContentProps as PopoverContentProps, index_d$e_PopoverPortalProps as PopoverPortalProps, index_d$e_PopoverProps as PopoverProps, index_d$e_PopoverTriggerProps as PopoverTriggerProps };
}

declare const createProgressScope: CreateScope;
type PrimitiveDivProps$9 = React.ComponentPropsWithoutRef<typeof Primitive.div>;
interface ProgressProps extends PrimitiveDivProps$9 {
    value?: number | null | undefined;
    max?: number;
    getValueLabel?(value: number, max: number): string;
}
declare const Progress: React.ForwardRefExoticComponent<ProgressProps & React.RefAttributes<HTMLDivElement>>;
interface ProgressIndicatorProps extends PrimitiveDivProps$9 {
}
declare const ProgressIndicator: React.ForwardRefExoticComponent<ProgressIndicatorProps & React.RefAttributes<HTMLDivElement>>;
declare const Root$7: React.ForwardRefExoticComponent<ProgressProps & React.RefAttributes<HTMLDivElement>>;
declare const Indicator: React.ForwardRefExoticComponent<ProgressIndicatorProps & React.RefAttributes<HTMLDivElement>>;

declare const index_d$d_Indicator: typeof Indicator;
declare const index_d$d_Progress: typeof Progress;
declare const index_d$d_ProgressIndicator: typeof ProgressIndicator;
type index_d$d_ProgressIndicatorProps = ProgressIndicatorProps;
type index_d$d_ProgressProps = ProgressProps;
declare const index_d$d_createProgressScope: typeof createProgressScope;
declare namespace index_d$d {
  export { index_d$d_Indicator as Indicator, index_d$d_Progress as Progress, index_d$d_ProgressIndicator as ProgressIndicator, Root$7 as Root, index_d$d_createProgressScope as createProgressScope };
  export type { index_d$d_ProgressIndicatorProps as ProgressIndicatorProps, index_d$d_ProgressProps as ProgressProps };
}

interface RadioProviderProps {
    checked?: boolean;
    required?: boolean;
    disabled?: boolean;
    name?: string;
    form?: string;
    value?: string | number | readonly string[];
    onCheck?(): void;
    children?: React.ReactNode;
}
interface RadioTriggerProps extends Omit<React.ComponentPropsWithoutRef<typeof Primitive.button>, keyof RadioProviderProps> {
    children?: React.ReactNode;
}
declare const RadioTrigger: React.ForwardRefExoticComponent<RadioTriggerProps & React.RefAttributes<HTMLButtonElement>>;
type PrimitiveButtonProps$7 = React.ComponentPropsWithoutRef<typeof Primitive.button>;
interface RadioProps$1 extends Omit<PrimitiveButtonProps$7, 'checked'> {
    checked?: boolean;
    required?: boolean;
    onCheck?(): void;
}
declare const Radio: React.ForwardRefExoticComponent<RadioProps$1 & React.RefAttributes<HTMLButtonElement>>;
type PrimitiveSpanProps$3 = React.ComponentPropsWithoutRef<typeof Primitive.span>;
interface RadioIndicatorProps$1 extends PrimitiveSpanProps$3 {
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: true;
}
declare const RadioIndicator: React.ForwardRefExoticComponent<RadioIndicatorProps$1 & React.RefAttributes<HTMLSpanElement>>;
type InputProps$1 = React.ComponentPropsWithoutRef<typeof Primitive.input>;
interface RadioBubbleInputProps extends Omit<InputProps$1, 'checked'> {
}
declare const RadioBubbleInput: React.ForwardRefExoticComponent<RadioBubbleInputProps & React.RefAttributes<HTMLInputElement>>;

type ScopedProps$3<P> = P & {
    __scopeRadioGroup?: Scope;
};
declare const createRadioGroupScope: CreateScope;
type RadioGroupContextValue = {
    name?: string;
    form?: string;
    required: boolean;
    disabled: boolean;
    value: string | null;
    onValueChange(value: string): void;
};
type RovingFocusGroupProps$3 = React.ComponentPropsWithoutRef<typeof Root$h>;
type PrimitiveDivProps$8 = React.ComponentPropsWithoutRef<typeof Primitive.div>;
interface RadioGroupProps extends PrimitiveDivProps$8 {
    name?: RadioGroupContextValue['name'];
    form?: React.ComponentPropsWithoutRef<typeof Radio>['form'];
    required?: React.ComponentPropsWithoutRef<typeof Radio>['required'];
    disabled?: React.ComponentPropsWithoutRef<typeof Radio>['disabled'];
    dir?: RovingFocusGroupProps$3['dir'];
    orientation?: RovingFocusGroupProps$3['orientation'];
    loop?: RovingFocusGroupProps$3['loop'];
    defaultValue?: string;
    value?: string | null;
    onValueChange?: RadioGroupContextValue['onValueChange'];
}
declare const RadioGroup: React.ForwardRefExoticComponent<RadioGroupProps & React.RefAttributes<HTMLDivElement>>;
interface RadioGroupItemProviderProps {
    value: string;
    disabled?: boolean;
    children?: React.ReactNode;
}
declare function RadioGroupItemProvider(props: ScopedProps$3<RadioGroupItemProviderProps>): react_jsx_runtime.JSX.Element;
interface RadioGroupItemTriggerProps extends React.ComponentPropsWithoutRef<typeof RadioTrigger> {
}
declare const RadioGroupItemTrigger: React.ForwardRefExoticComponent<RadioGroupItemTriggerProps & React.RefAttributes<HTMLButtonElement>>;
type RadioProps = React.ComponentPropsWithoutRef<typeof Radio>;
interface RadioGroupItemProps extends Omit<RadioProps, 'onCheck' | 'name'> {
    value: string;
}
declare const RadioGroupItem: React.ForwardRefExoticComponent<RadioGroupItemProps & React.RefAttributes<HTMLButtonElement>>;
interface RadioGroupItemBubbleInputProps extends React.ComponentPropsWithoutRef<typeof RadioBubbleInput> {
}
declare const RadioGroupItemBubbleInput: React.ForwardRefExoticComponent<RadioGroupItemBubbleInputProps & React.RefAttributes<HTMLInputElement>>;
type RadioIndicatorProps = React.ComponentPropsWithoutRef<typeof RadioIndicator>;
interface RadioGroupIndicatorProps extends RadioIndicatorProps {
}
declare const RadioGroupIndicator: React.ForwardRefExoticComponent<RadioGroupIndicatorProps & React.RefAttributes<HTMLSpanElement>>;

declare const index_d$c_RadioGroup: typeof RadioGroup;
declare const index_d$c_RadioGroupIndicator: typeof RadioGroupIndicator;
type index_d$c_RadioGroupIndicatorProps = RadioGroupIndicatorProps;
declare const index_d$c_RadioGroupItem: typeof RadioGroupItem;
type index_d$c_RadioGroupItemProps = RadioGroupItemProps;
type index_d$c_RadioGroupProps = RadioGroupProps;
declare const index_d$c_createRadioGroupScope: typeof createRadioGroupScope;
declare namespace index_d$c {
  export { RadioGroupIndicator as Indicator, RadioGroupItem as Item, index_d$c_RadioGroup as RadioGroup, index_d$c_RadioGroupIndicator as RadioGroupIndicator, index_d$c_RadioGroupItem as RadioGroupItem, RadioGroup as Root, index_d$c_createRadioGroupScope as createRadioGroupScope, RadioGroupItemBubbleInput as unstable_ItemBubbleInput, RadioGroupItemProvider as unstable_ItemProvider, RadioGroupItemTrigger as unstable_ItemTrigger, RadioGroupItemBubbleInput as unstable_RadioGroupItemBubbleInput, RadioGroupItemProvider as unstable_RadioGroupItemProvider, RadioGroupItemTrigger as unstable_RadioGroupItemTrigger };
  export type { index_d$c_RadioGroupIndicatorProps as RadioGroupIndicatorProps, index_d$c_RadioGroupItemProps as RadioGroupItemProps, index_d$c_RadioGroupProps as RadioGroupProps, RadioGroupItemBubbleInputProps as unstable_RadioGroupItemBubbleInputProps, RadioGroupItemProviderProps as unstable_RadioGroupItemProviderProps, RadioGroupItemTriggerProps as unstable_RadioGroupItemTriggerProps };
}

type Direction$2 = 'ltr' | 'rtl';
type Sizes = {
    content: number;
    viewport: number;
    scrollbar: {
        size: number;
        paddingStart: number;
        paddingEnd: number;
    };
};
declare const createScrollAreaScope: CreateScope;
type ScrollAreaContextValue = {
    type: 'auto' | 'always' | 'scroll' | 'hover';
    dir: Direction$2;
    scrollHideDelay: number;
    scrollArea: ScrollAreaElement | null;
    viewport: ScrollAreaViewportElement | null;
    onViewportChange(viewport: ScrollAreaViewportElement | null): void;
    content: HTMLDivElement | null;
    onContentChange(content: HTMLDivElement): void;
    scrollbarX: ScrollAreaScrollbarElement | null;
    onScrollbarXChange(scrollbar: ScrollAreaScrollbarElement | null): void;
    scrollbarXEnabled: boolean;
    onScrollbarXEnabledChange(rendered: boolean): void;
    scrollbarY: ScrollAreaScrollbarElement | null;
    onScrollbarYChange(scrollbar: ScrollAreaScrollbarElement | null): void;
    scrollbarYEnabled: boolean;
    onScrollbarYEnabledChange(rendered: boolean): void;
    onCornerWidthChange(width: number): void;
    onCornerHeightChange(height: number): void;
};
type ScrollAreaElement = React.ComponentRef<typeof Primitive.div>;
type PrimitiveDivProps$7 = React.ComponentPropsWithoutRef<typeof Primitive.div>;
interface ScrollAreaProps extends PrimitiveDivProps$7 {
    type?: ScrollAreaContextValue['type'];
    dir?: ScrollAreaContextValue['dir'];
    scrollHideDelay?: number;
}
declare const ScrollArea: React.ForwardRefExoticComponent<ScrollAreaProps & React.RefAttributes<HTMLDivElement>>;
type ScrollAreaViewportElement = React.ComponentRef<typeof Primitive.div>;
interface ScrollAreaViewportProps extends PrimitiveDivProps$7 {
    nonce?: string;
}
declare const ScrollAreaViewport: React.ForwardRefExoticComponent<ScrollAreaViewportProps & React.RefAttributes<HTMLDivElement>>;
type ScrollAreaScrollbarElement = ScrollAreaScrollbarVisibleElement;
interface ScrollAreaScrollbarProps extends ScrollAreaScrollbarVisibleProps {
    forceMount?: true;
}
declare const ScrollAreaScrollbar: React.ForwardRefExoticComponent<ScrollAreaScrollbarProps & React.RefAttributes<HTMLDivElement>>;
type ScrollAreaScrollbarVisibleElement = ScrollAreaScrollbarAxisElement;
interface ScrollAreaScrollbarVisibleProps extends Omit<ScrollAreaScrollbarAxisProps, keyof ScrollAreaScrollbarAxisPrivateProps> {
    orientation?: 'horizontal' | 'vertical';
}
type ScrollAreaScrollbarAxisPrivateProps = {
    hasThumb: boolean;
    sizes: Sizes;
    onSizesChange(sizes: Sizes): void;
    onThumbChange(thumb: ScrollAreaThumbElement | null): void;
    onThumbPointerDown(pointerPos: number): void;
    onThumbPointerUp(): void;
    onThumbPositionChange(): void;
    onWheelScroll(scrollPos: number): void;
    onDragScroll(pointerPos: number): void;
};
type ScrollAreaScrollbarAxisElement = ScrollAreaScrollbarImplElement;
interface ScrollAreaScrollbarAxisProps extends Omit<ScrollAreaScrollbarImplProps, keyof ScrollAreaScrollbarImplPrivateProps>, ScrollAreaScrollbarAxisPrivateProps {
}
type ScrollbarContext = {
    hasThumb: boolean;
    scrollbar: ScrollAreaScrollbarElement | null;
    onThumbChange(thumb: ScrollAreaThumbElement | null): void;
    onThumbPointerUp(): void;
    onThumbPointerDown(pointerPos: {
        x: number;
        y: number;
    }): void;
    onThumbPositionChange(): void;
};
type ScrollAreaScrollbarImplElement = React.ComponentRef<typeof Primitive.div>;
type ScrollAreaScrollbarImplPrivateProps = {
    sizes: Sizes;
    hasThumb: boolean;
    onThumbChange: ScrollbarContext['onThumbChange'];
    onThumbPointerUp: ScrollbarContext['onThumbPointerUp'];
    onThumbPointerDown: ScrollbarContext['onThumbPointerDown'];
    onThumbPositionChange: ScrollbarContext['onThumbPositionChange'];
    onWheelScroll(event: WheelEvent, maxScrollPos: number): void;
    onDragScroll(pointerPos: {
        x: number;
        y: number;
    }): void;
    onResize(): void;
};
interface ScrollAreaScrollbarImplProps extends Omit<PrimitiveDivProps$7, keyof ScrollAreaScrollbarImplPrivateProps>, ScrollAreaScrollbarImplPrivateProps {
}
type ScrollAreaThumbElement = ScrollAreaThumbImplElement;
interface ScrollAreaThumbProps extends ScrollAreaThumbImplProps {
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: true;
}
declare const ScrollAreaThumb: React.ForwardRefExoticComponent<ScrollAreaThumbProps & React.RefAttributes<HTMLDivElement>>;
type ScrollAreaThumbImplElement = React.ComponentRef<typeof Primitive.div>;
interface ScrollAreaThumbImplProps extends PrimitiveDivProps$7 {
}
interface ScrollAreaCornerProps extends ScrollAreaCornerImplProps {
}
declare const ScrollAreaCorner: React.ForwardRefExoticComponent<ScrollAreaCornerProps & React.RefAttributes<HTMLDivElement>>;
interface ScrollAreaCornerImplProps extends PrimitiveDivProps$7 {
}
declare const Root$6: React.ForwardRefExoticComponent<ScrollAreaProps & React.RefAttributes<HTMLDivElement>>;
declare const Viewport$1: React.ForwardRefExoticComponent<ScrollAreaViewportProps & React.RefAttributes<HTMLDivElement>>;
declare const Scrollbar: React.ForwardRefExoticComponent<ScrollAreaScrollbarProps & React.RefAttributes<HTMLDivElement>>;
declare const Thumb: React.ForwardRefExoticComponent<ScrollAreaThumbProps & React.RefAttributes<HTMLDivElement>>;
declare const Corner: React.ForwardRefExoticComponent<ScrollAreaCornerProps & React.RefAttributes<HTMLDivElement>>;

declare const index_d$b_Corner: typeof Corner;
declare const index_d$b_ScrollArea: typeof ScrollArea;
declare const index_d$b_ScrollAreaCorner: typeof ScrollAreaCorner;
type index_d$b_ScrollAreaCornerProps = ScrollAreaCornerProps;
type index_d$b_ScrollAreaProps = ScrollAreaProps;
declare const index_d$b_ScrollAreaScrollbar: typeof ScrollAreaScrollbar;
type index_d$b_ScrollAreaScrollbarProps = ScrollAreaScrollbarProps;
declare const index_d$b_ScrollAreaThumb: typeof ScrollAreaThumb;
type index_d$b_ScrollAreaThumbProps = ScrollAreaThumbProps;
declare const index_d$b_ScrollAreaViewport: typeof ScrollAreaViewport;
type index_d$b_ScrollAreaViewportProps = ScrollAreaViewportProps;
declare const index_d$b_Scrollbar: typeof Scrollbar;
declare const index_d$b_Thumb: typeof Thumb;
declare const index_d$b_createScrollAreaScope: typeof createScrollAreaScope;
declare namespace index_d$b {
  export { index_d$b_Corner as Corner, Root$6 as Root, index_d$b_ScrollArea as ScrollArea, index_d$b_ScrollAreaCorner as ScrollAreaCorner, index_d$b_ScrollAreaScrollbar as ScrollAreaScrollbar, index_d$b_ScrollAreaThumb as ScrollAreaThumb, index_d$b_ScrollAreaViewport as ScrollAreaViewport, index_d$b_Scrollbar as Scrollbar, index_d$b_Thumb as Thumb, Viewport$1 as Viewport, index_d$b_createScrollAreaScope as createScrollAreaScope };
  export type { index_d$b_ScrollAreaCornerProps as ScrollAreaCornerProps, index_d$b_ScrollAreaProps as ScrollAreaProps, index_d$b_ScrollAreaScrollbarProps as ScrollAreaScrollbarProps, index_d$b_ScrollAreaThumbProps as ScrollAreaThumbProps, index_d$b_ScrollAreaViewportProps as ScrollAreaViewportProps };
}

type Direction$1 = 'ltr' | 'rtl';
type ScopedProps$2<P> = P & {
    __scopeSelect?: Scope;
};
declare const createSelectScope: CreateScope;
interface SelectSharedProps {
    children?: React.ReactNode;
    open?: boolean;
    defaultOpen?: boolean;
    onOpenChange?(open: boolean): void;
    dir?: Direction$1;
    name?: string;
    autoComplete?: string;
    disabled?: boolean;
    required?: boolean;
    form?: string;
}
type SelectProps = SelectSharedProps & {
    value?: string;
    defaultValue?: string;
    onValueChange?(value: string): void;
};
interface SelectProviderProps extends SelectSharedProps {
    value?: string;
    defaultValue?: string;
    onValueChange?(value: string): void;
}
declare function SelectProvider(props: ScopedProps$2<SelectProviderProps>): react_jsx_runtime.JSX.Element;
declare const Select: React.FC<SelectProps>;
type PrimitiveButtonProps$6 = React.ComponentPropsWithoutRef<typeof Primitive.button>;
interface SelectTriggerProps extends PrimitiveButtonProps$6 {
}
declare const SelectTrigger: React.ForwardRefExoticComponent<SelectTriggerProps & React.RefAttributes<HTMLButtonElement>>;
type PrimitiveSpanProps$2 = React.ComponentPropsWithoutRef<typeof Primitive.span>;
interface SelectValueProps extends Omit<PrimitiveSpanProps$2, 'placeholder'> {
    placeholder?: React.ReactNode;
}
declare const SelectValue: React.ForwardRefExoticComponent<SelectValueProps & React.RefAttributes<HTMLSpanElement>>;
interface SelectIconProps extends PrimitiveSpanProps$2 {
}
declare const SelectIcon: React.ForwardRefExoticComponent<SelectIconProps & React.RefAttributes<HTMLSpanElement>>;
type PortalProps$1 = React.ComponentPropsWithoutRef<typeof Portal$8>;
interface SelectPortalProps {
    children?: React.ReactNode;
    /**
     * Specify a container element to portal the content into.
     */
    container?: PortalProps$1['container'];
    /**
     * Used to force mounting when more control is needed. Useful when controlling
     * animation with React animation libraries.
     */
    forceMount?: true;
}
declare const SelectPortal: React.FC<SelectPortalProps>;
interface SelectContentProps extends SelectContentImplProps {
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: true;
}
declare const SelectContent: React.ForwardRefExoticComponent<SelectContentProps & React.RefAttributes<HTMLDivElement>>;
type DismissableLayerProps$2 = React.ComponentPropsWithoutRef<typeof DismissableLayer>;
type FocusScopeProps = React.ComponentPropsWithoutRef<typeof FocusScope>;
type SelectPopperPrivateProps = {
    onPlaced?: PopperContentProps$1['onPlaced'];
};
interface SelectContentImplProps extends Omit<SelectPopperPositionProps, keyof SelectPopperPrivateProps>, Omit<SelectItemAlignedPositionProps, keyof SelectPopperPrivateProps> {
    /**
     * Event handler called when auto-focusing on close.
     * Can be prevented.
     */
    onCloseAutoFocus?: FocusScopeProps['onUnmountAutoFocus'];
    /**
     * Event handler called when the escape key is down.
     * Can be prevented.
     */
    onEscapeKeyDown?: DismissableLayerProps$2['onEscapeKeyDown'];
    /**
     * Event handler called when the a `pointerdown` event happens outside of the `DismissableLayer`.
     * Can be prevented.
     */
    onPointerDownOutside?: DismissableLayerProps$2['onPointerDownOutside'];
    position?: 'item-aligned' | 'popper';
}
interface SelectItemAlignedPositionProps extends PrimitiveDivProps$6, SelectPopperPrivateProps {
}
type PopperContentProps$1 = React.ComponentPropsWithoutRef<typeof Content$9>;
interface SelectPopperPositionProps extends PopperContentProps$1, SelectPopperPrivateProps {
}
type PrimitiveDivProps$6 = React.ComponentPropsWithoutRef<typeof Primitive.div>;
interface SelectViewportProps extends PrimitiveDivProps$6 {
    nonce?: string;
}
declare const SelectViewport: React.ForwardRefExoticComponent<SelectViewportProps & React.RefAttributes<HTMLDivElement>>;
interface SelectGroupProps extends PrimitiveDivProps$6 {
}
declare const SelectGroup: React.ForwardRefExoticComponent<SelectGroupProps & React.RefAttributes<HTMLDivElement>>;
interface SelectLabelProps extends PrimitiveDivProps$6 {
}
declare const SelectLabel: React.ForwardRefExoticComponent<SelectLabelProps & React.RefAttributes<HTMLDivElement>>;
interface SelectItemProps extends PrimitiveDivProps$6 {
    value: string;
    disabled?: boolean;
    textValue?: string;
}
declare const SelectItem: React.ForwardRefExoticComponent<SelectItemProps & React.RefAttributes<HTMLDivElement>>;
interface SelectItemTextProps extends PrimitiveSpanProps$2 {
}
declare const SelectItemText: React.ForwardRefExoticComponent<SelectItemTextProps & React.RefAttributes<HTMLSpanElement>>;
interface SelectItemIndicatorProps extends PrimitiveSpanProps$2 {
}
declare const SelectItemIndicator: React.ForwardRefExoticComponent<SelectItemIndicatorProps & React.RefAttributes<HTMLSpanElement>>;
interface SelectScrollUpButtonProps extends Omit<SelectScrollButtonImplProps, 'onAutoScroll'> {
}
declare const SelectScrollUpButton: React.ForwardRefExoticComponent<SelectScrollUpButtonProps & React.RefAttributes<HTMLDivElement>>;
interface SelectScrollDownButtonProps extends Omit<SelectScrollButtonImplProps, 'onAutoScroll'> {
}
declare const SelectScrollDownButton: React.ForwardRefExoticComponent<SelectScrollDownButtonProps & React.RefAttributes<HTMLDivElement>>;
interface SelectScrollButtonImplProps extends PrimitiveDivProps$6 {
    onAutoScroll(): void;
}
interface SelectSeparatorProps extends PrimitiveDivProps$6 {
}
declare const SelectSeparator: React.ForwardRefExoticComponent<SelectSeparatorProps & React.RefAttributes<HTMLDivElement>>;
type PopperArrowProps$1 = React.ComponentPropsWithoutRef<typeof Arrow$7>;
interface SelectArrowProps extends PopperArrowProps$1 {
}
declare const SelectArrow: React.ForwardRefExoticComponent<SelectArrowProps & React.RefAttributes<SVGSVGElement>>;
type PrimitiveSelectProps = React.ComponentPropsWithoutRef<typeof Primitive.select>;
interface SelectBubbleInputProps extends Omit<PrimitiveSelectProps, 'value'> {
}
declare const SelectBubbleInput: React.ForwardRefExoticComponent<SelectBubbleInputProps & React.RefAttributes<HTMLSelectElement>>;

declare const index_d$a_Select: typeof Select;
declare const index_d$a_SelectArrow: typeof SelectArrow;
type index_d$a_SelectArrowProps = SelectArrowProps;
declare const index_d$a_SelectContent: typeof SelectContent;
type index_d$a_SelectContentProps = SelectContentProps;
declare const index_d$a_SelectGroup: typeof SelectGroup;
type index_d$a_SelectGroupProps = SelectGroupProps;
declare const index_d$a_SelectIcon: typeof SelectIcon;
type index_d$a_SelectIconProps = SelectIconProps;
declare const index_d$a_SelectItem: typeof SelectItem;
declare const index_d$a_SelectItemIndicator: typeof SelectItemIndicator;
type index_d$a_SelectItemIndicatorProps = SelectItemIndicatorProps;
type index_d$a_SelectItemProps = SelectItemProps;
declare const index_d$a_SelectItemText: typeof SelectItemText;
type index_d$a_SelectItemTextProps = SelectItemTextProps;
declare const index_d$a_SelectLabel: typeof SelectLabel;
type index_d$a_SelectLabelProps = SelectLabelProps;
declare const index_d$a_SelectPortal: typeof SelectPortal;
type index_d$a_SelectPortalProps = SelectPortalProps;
type index_d$a_SelectProps = SelectProps;
declare const index_d$a_SelectScrollDownButton: typeof SelectScrollDownButton;
type index_d$a_SelectScrollDownButtonProps = SelectScrollDownButtonProps;
declare const index_d$a_SelectScrollUpButton: typeof SelectScrollUpButton;
type index_d$a_SelectScrollUpButtonProps = SelectScrollUpButtonProps;
declare const index_d$a_SelectSeparator: typeof SelectSeparator;
type index_d$a_SelectSeparatorProps = SelectSeparatorProps;
type index_d$a_SelectSharedProps = SelectSharedProps;
declare const index_d$a_SelectTrigger: typeof SelectTrigger;
type index_d$a_SelectTriggerProps = SelectTriggerProps;
declare const index_d$a_SelectValue: typeof SelectValue;
type index_d$a_SelectValueProps = SelectValueProps;
declare const index_d$a_SelectViewport: typeof SelectViewport;
type index_d$a_SelectViewportProps = SelectViewportProps;
declare const index_d$a_createSelectScope: typeof createSelectScope;
declare namespace index_d$a {
  export { SelectArrow as Arrow, SelectContent as Content, SelectGroup as Group, SelectIcon as Icon, SelectItem as Item, SelectItemIndicator as ItemIndicator, SelectItemText as ItemText, SelectLabel as Label, SelectPortal as Portal, Select as Root, SelectScrollDownButton as ScrollDownButton, SelectScrollUpButton as ScrollUpButton, index_d$a_Select as Select, index_d$a_SelectArrow as SelectArrow, index_d$a_SelectContent as SelectContent, index_d$a_SelectGroup as SelectGroup, index_d$a_SelectIcon as SelectIcon, index_d$a_SelectItem as SelectItem, index_d$a_SelectItemIndicator as SelectItemIndicator, index_d$a_SelectItemText as SelectItemText, index_d$a_SelectLabel as SelectLabel, index_d$a_SelectPortal as SelectPortal, index_d$a_SelectScrollDownButton as SelectScrollDownButton, index_d$a_SelectScrollUpButton as SelectScrollUpButton, index_d$a_SelectSeparator as SelectSeparator, index_d$a_SelectTrigger as SelectTrigger, index_d$a_SelectValue as SelectValue, index_d$a_SelectViewport as SelectViewport, SelectSeparator as Separator, SelectTrigger as Trigger, SelectValue as Value, SelectViewport as Viewport, index_d$a_createSelectScope as createSelectScope, SelectBubbleInput as unstable_BubbleInput, SelectProvider as unstable_Provider, SelectBubbleInput as unstable_SelectBubbleInput, SelectProvider as unstable_SelectProvider };
  export type { index_d$a_SelectArrowProps as SelectArrowProps, index_d$a_SelectContentProps as SelectContentProps, index_d$a_SelectGroupProps as SelectGroupProps, index_d$a_SelectIconProps as SelectIconProps, index_d$a_SelectItemIndicatorProps as SelectItemIndicatorProps, index_d$a_SelectItemProps as SelectItemProps, index_d$a_SelectItemTextProps as SelectItemTextProps, index_d$a_SelectLabelProps as SelectLabelProps, index_d$a_SelectPortalProps as SelectPortalProps, index_d$a_SelectProps as SelectProps, index_d$a_SelectScrollDownButtonProps as SelectScrollDownButtonProps, index_d$a_SelectScrollUpButtonProps as SelectScrollUpButtonProps, index_d$a_SelectSeparatorProps as SelectSeparatorProps, index_d$a_SelectSharedProps as SelectSharedProps, index_d$a_SelectTriggerProps as SelectTriggerProps, index_d$a_SelectValueProps as SelectValueProps, index_d$a_SelectViewportProps as SelectViewportProps, SelectBubbleInputProps as unstable_SelectBubbleInputProps, SelectProviderProps as unstable_SelectProviderProps };
}

declare const ORIENTATIONS: readonly ["horizontal", "vertical"];
type Orientation = (typeof ORIENTATIONS)[number];
type PrimitiveDivProps$5 = React.ComponentPropsWithoutRef<typeof Primitive.div>;
interface SeparatorProps$1 extends PrimitiveDivProps$5 {
    /**
     * Either `vertical` or `horizontal`. Defaults to `horizontal`.
     */
    orientation?: Orientation;
    /**
     * Whether or not the component is purely decorative. When true, accessibility-related attributes
     * are updated so that that the rendered element is removed from the accessibility tree.
     */
    decorative?: boolean;
}
declare const Separator$1: React.ForwardRefExoticComponent<SeparatorProps$1 & React.RefAttributes<HTMLDivElement>>;
declare const Root$5: React.ForwardRefExoticComponent<SeparatorProps$1 & React.RefAttributes<HTMLDivElement>>;

declare namespace index_d$9 {
  export { Root$5 as Root, Separator$1 as Separator };
  export type { SeparatorProps$1 as SeparatorProps };
}

type Direction = 'ltr' | 'rtl';
declare global {
    interface FocusOptions {
        /**
         * A boolean value that should be set to `true` to force, or `false` to prevent
         * visible indication that the element is focused. If the property is not
         * specified, a browser will provide visible indication if it determines
         * that this would improve accessibility for users.
         *
         * @see
         * https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/focus#focusvisible
         */
        focusVisible?: boolean;
    }
}
type ScopedProps$1<P> = P & {
    __scopeSlider?: Scope;
};
declare const createSliderScope: CreateScope;
interface SliderProps extends Omit<SliderHorizontalProps | SliderVerticalProps, keyof SliderOrientationPrivateProps | 'defaultValue'> {
    name?: string;
    disabled?: boolean;
    orientation?: React.AriaAttributes['aria-orientation'];
    dir?: Direction;
    min?: number;
    max?: number;
    step?: number;
    minStepsBetweenThumbs?: number;
    value?: number[];
    defaultValue?: number[];
    onValueChange?(value: number[]): void;
    onValueCommit?(value: number[]): void;
    inverted?: boolean;
    form?: string;
}
declare const Slider: React.ForwardRefExoticComponent<SliderProps & React.RefAttributes<HTMLSpanElement>>;
type SliderOrientationPrivateProps = {
    min: number;
    max: number;
    inverted: boolean;
    onSlideStart?(value: number): void;
    onSlideMove?(value: number): void;
    onSlideEnd?(): void;
    onHomeKeyDown(event: React.KeyboardEvent): void;
    onEndKeyDown(event: React.KeyboardEvent): void;
    onStepKeyDown(step: {
        event: React.KeyboardEvent;
        direction: number;
    }): void;
};
interface SliderOrientationProps extends Omit<SliderImplProps, keyof SliderImplPrivateProps>, SliderOrientationPrivateProps {
}
interface SliderHorizontalProps extends SliderOrientationProps {
    dir?: Direction;
}
interface SliderVerticalProps extends SliderOrientationProps {
}
type PrimitiveDivProps$4 = React.ComponentPropsWithoutRef<typeof Primitive.div>;
type SliderImplPrivateProps = {
    onSlideStart(event: React.PointerEvent): void;
    onSlideMove(event: React.PointerEvent): void;
    onSlideEnd(event: React.PointerEvent): void;
    onHomeKeyDown(event: React.KeyboardEvent): void;
    onEndKeyDown(event: React.KeyboardEvent): void;
    onStepKeyDown(event: React.KeyboardEvent): void;
};
interface SliderImplProps extends PrimitiveDivProps$4, SliderImplPrivateProps {
}
type PrimitiveSpanProps$1 = React.ComponentPropsWithoutRef<typeof Primitive.span>;
interface SliderTrackProps extends PrimitiveSpanProps$1 {
}
declare const SliderTrack: React.ForwardRefExoticComponent<SliderTrackProps & React.RefAttributes<HTMLSpanElement>>;
interface SliderRangeProps extends PrimitiveSpanProps$1 {
}
declare const SliderRange: React.ForwardRefExoticComponent<SliderRangeProps & React.RefAttributes<HTMLSpanElement>>;
interface SliderThumbProviderProps {
    name?: string;
    children?: React.ReactNode;
}
declare function SliderThumbProvider(props: ScopedProps$1<SliderThumbProviderProps>): react_jsx_runtime.JSX.Element;
interface SliderThumbTriggerProps extends PrimitiveSpanProps$1 {
}
declare const SliderThumbTrigger: React.ForwardRefExoticComponent<SliderThumbTriggerProps & React.RefAttributes<HTMLSpanElement>>;
interface SliderThumbProps extends SliderThumbTriggerProps {
    name?: string;
}
declare const SliderThumb: React.ForwardRefExoticComponent<SliderThumbProps & React.RefAttributes<HTMLSpanElement>>;
type PrimitiveInputProps = React.ComponentPropsWithoutRef<typeof Primitive.input>;
interface SliderBubbleInputProps extends Omit<PrimitiveInputProps, 'value'> {
}
declare const SliderBubbleInput: React.ForwardRefExoticComponent<SliderBubbleInputProps & React.RefAttributes<HTMLInputElement>>;

declare const index_d$8_Slider: typeof Slider;
type index_d$8_SliderProps = SliderProps;
declare const index_d$8_SliderRange: typeof SliderRange;
type index_d$8_SliderRangeProps = SliderRangeProps;
declare const index_d$8_SliderThumb: typeof SliderThumb;
type index_d$8_SliderThumbProps = SliderThumbProps;
declare const index_d$8_SliderTrack: typeof SliderTrack;
type index_d$8_SliderTrackProps = SliderTrackProps;
declare const index_d$8_createSliderScope: typeof createSliderScope;
declare namespace index_d$8 {
  export { SliderRange as Range, Slider as Root, index_d$8_Slider as Slider, index_d$8_SliderRange as SliderRange, index_d$8_SliderThumb as SliderThumb, index_d$8_SliderTrack as SliderTrack, SliderThumb as Thumb, SliderTrack as Track, index_d$8_createSliderScope as createSliderScope, SliderBubbleInput as unstable_BubbleInput, SliderBubbleInput as unstable_SliderBubbleInput, SliderThumbProvider as unstable_SliderThumbProvider, SliderThumbTrigger as unstable_SliderThumbTrigger, SliderThumbProvider as unstable_ThumbProvider, SliderThumbTrigger as unstable_ThumbTrigger };
  export type { index_d$8_SliderProps as SliderProps, index_d$8_SliderRangeProps as SliderRangeProps, index_d$8_SliderThumbProps as SliderThumbProps, index_d$8_SliderTrackProps as SliderTrackProps, SliderBubbleInputProps as unstable_SliderBubbleInputProps, SliderThumbProviderProps as unstable_SliderThumbProviderProps, SliderThumbTriggerProps as unstable_SliderThumbTriggerProps };
}

type SlotProps<Elem extends Element = HTMLElement, Props = React.HTMLAttributes<Elem>> = Props & {
    children?: React.ReactNode;
};
declare function createSlot<Elem extends Element = HTMLElement, Props = React.HTMLAttributes<Elem>>(ownerName: string): React.ForwardRefExoticComponent<React.PropsWithoutRef<SlotProps<Elem, Props>> & React.RefAttributes<Elem>>;
declare const Slot: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLElement> & {
    children?: React.ReactNode;
} & React.RefAttributes<HTMLElement>>;
type SlottableChildrenProps = {
    children: React.ReactNode;
};
type SlottableRenderFnProps = {
    child: React.ReactNode;
    children: (slottable: React.ReactNode) => React.ReactNode;
};
type SlottableProps = SlottableRenderFnProps | SlottableChildrenProps;
interface SlottableComponent extends React.FC<SlottableProps> {
    __radixId: symbol;
}
declare function createSlottable(ownerName: string): SlottableComponent;
declare const Slottable: SlottableComponent;

declare const index_d$7_Slot: typeof Slot;
type index_d$7_SlotProps<Elem extends Element = HTMLElement, Props = React.HTMLAttributes<Elem>> = SlotProps<Elem, Props>;
declare const index_d$7_Slottable: typeof Slottable;
declare const index_d$7_createSlot: typeof createSlot;
declare const index_d$7_createSlottable: typeof createSlottable;
declare namespace index_d$7 {
  export { Slot as Root, index_d$7_Slot as Slot, index_d$7_Slottable as Slottable, index_d$7_createSlot as createSlot, index_d$7_createSlottable as createSlottable };
  export type { index_d$7_SlotProps as SlotProps };
}

type ScopedProps<P> = P & {
    __scopeSwitch?: Scope;
};
declare const createSwitchScope: CreateScope;
interface SwitchProviderProps {
    checked?: boolean;
    defaultChecked?: boolean;
    required?: boolean;
    onCheckedChange?(checked: boolean): void;
    name?: string;
    form?: string;
    disabled?: boolean;
    value?: string | number | readonly string[];
    children?: React.ReactNode;
}
declare function SwitchProvider(props: ScopedProps<SwitchProviderProps>): react_jsx_runtime.JSX.Element;
interface SwitchTriggerProps extends Omit<React.ComponentPropsWithoutRef<typeof Primitive.button>, keyof SwitchProviderProps> {
    children?: React.ReactNode;
}
declare const SwitchTrigger: React.ForwardRefExoticComponent<SwitchTriggerProps & React.RefAttributes<HTMLButtonElement>>;
type PrimitiveButtonProps$5 = React.ComponentPropsWithoutRef<typeof Primitive.button>;
interface SwitchProps extends Omit<PrimitiveButtonProps$5, 'checked' | 'defaultChecked'> {
    checked?: boolean;
    defaultChecked?: boolean;
    required?: boolean;
    onCheckedChange?(checked: boolean): void;
}
declare const Switch: React.ForwardRefExoticComponent<SwitchProps & React.RefAttributes<HTMLButtonElement>>;
type PrimitiveSpanProps = React.ComponentPropsWithoutRef<typeof Primitive.span>;
interface SwitchThumbProps extends PrimitiveSpanProps {
}
declare const SwitchThumb: React.ForwardRefExoticComponent<SwitchThumbProps & React.RefAttributes<HTMLSpanElement>>;
type InputProps = React.ComponentPropsWithoutRef<typeof Primitive.input>;
interface SwitchBubbleInputProps extends Omit<InputProps, 'checked'> {
}
declare const SwitchBubbleInput: React.ForwardRefExoticComponent<SwitchBubbleInputProps & React.RefAttributes<HTMLInputElement>>;

declare const index_d$6_Switch: typeof Switch;
type index_d$6_SwitchProps = SwitchProps;
declare const index_d$6_SwitchThumb: typeof SwitchThumb;
type index_d$6_SwitchThumbProps = SwitchThumbProps;
declare const index_d$6_createSwitchScope: typeof createSwitchScope;
declare namespace index_d$6 {
  export { Switch as Root, index_d$6_Switch as Switch, index_d$6_SwitchThumb as SwitchThumb, SwitchThumb as Thumb, index_d$6_createSwitchScope as createSwitchScope, SwitchBubbleInput as unstable_BubbleInput, SwitchProvider as unstable_Provider, SwitchBubbleInput as unstable_SwitchBubbleInput, SwitchProvider as unstable_SwitchProvider, SwitchTrigger as unstable_SwitchTrigger, SwitchTrigger as unstable_Trigger };
  export type { index_d$6_SwitchProps as SwitchProps, index_d$6_SwitchThumbProps as SwitchThumbProps, SwitchBubbleInputProps as unstable_SwitchBubbleInputProps, SwitchProviderProps as unstable_SwitchProviderProps, SwitchTriggerProps as unstable_SwitchTriggerProps };
}

declare const createTabsScope: CreateScope;
type RovingFocusGroupProps$2 = React.ComponentPropsWithoutRef<typeof Root$h>;
type PrimitiveDivProps$3 = React.ComponentPropsWithoutRef<typeof Primitive.div>;
interface TabsProps extends PrimitiveDivProps$3 {
    /** The value for the selected tab, if controlled */
    value?: string;
    /** The value of the tab to select by default, if uncontrolled */
    defaultValue?: string;
    /** A function called when a new tab is selected */
    onValueChange?: (value: string) => void;
    /**
     * The orientation the tabs are layed out.
     * Mainly so arrow navigation is done accordingly (left & right vs. up & down)
     * @defaultValue horizontal
     */
    orientation?: RovingFocusGroupProps$2['orientation'];
    /**
     * The direction of navigation between toolbar items.
     */
    dir?: RovingFocusGroupProps$2['dir'];
    /**
     * Whether a tab is activated automatically or manually.
     * @defaultValue automatic
     * */
    activationMode?: 'automatic' | 'manual';
}
declare const Tabs: React.ForwardRefExoticComponent<TabsProps & React.RefAttributes<HTMLDivElement>>;
interface TabsListProps extends PrimitiveDivProps$3 {
    loop?: RovingFocusGroupProps$2['loop'];
}
declare const TabsList: React.ForwardRefExoticComponent<TabsListProps & React.RefAttributes<HTMLDivElement>>;
type PrimitiveButtonProps$4 = React.ComponentPropsWithoutRef<typeof Primitive.button>;
interface TabsTriggerProps extends PrimitiveButtonProps$4 {
    value: string;
}
declare const TabsTrigger: React.ForwardRefExoticComponent<TabsTriggerProps & React.RefAttributes<HTMLButtonElement>>;
interface TabsContentProps extends PrimitiveDivProps$3 {
    value: string;
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: true;
}
declare const TabsContent: React.ForwardRefExoticComponent<TabsContentProps & React.RefAttributes<HTMLDivElement>>;
declare const Root$4: React.ForwardRefExoticComponent<TabsProps & React.RefAttributes<HTMLDivElement>>;
declare const List: React.ForwardRefExoticComponent<TabsListProps & React.RefAttributes<HTMLDivElement>>;
declare const Trigger$1: React.ForwardRefExoticComponent<TabsTriggerProps & React.RefAttributes<HTMLButtonElement>>;
declare const Content$1: React.ForwardRefExoticComponent<TabsContentProps & React.RefAttributes<HTMLDivElement>>;

declare const index_d$5_List: typeof List;
declare const index_d$5_Tabs: typeof Tabs;
declare const index_d$5_TabsContent: typeof TabsContent;
type index_d$5_TabsContentProps = TabsContentProps;
declare const index_d$5_TabsList: typeof TabsList;
type index_d$5_TabsListProps = TabsListProps;
type index_d$5_TabsProps = TabsProps;
declare const index_d$5_TabsTrigger: typeof TabsTrigger;
type index_d$5_TabsTriggerProps = TabsTriggerProps;
declare const index_d$5_createTabsScope: typeof createTabsScope;
declare namespace index_d$5 {
  export { Content$1 as Content, index_d$5_List as List, Root$4 as Root, index_d$5_Tabs as Tabs, index_d$5_TabsContent as TabsContent, index_d$5_TabsList as TabsList, index_d$5_TabsTrigger as TabsTrigger, Trigger$1 as Trigger, index_d$5_createTabsScope as createTabsScope };
  export type { index_d$5_TabsContentProps as TabsContentProps, index_d$5_TabsListProps as TabsListProps, index_d$5_TabsProps as TabsProps, index_d$5_TabsTriggerProps as TabsTriggerProps };
}

type SwipeDirection = 'up' | 'down' | 'left' | 'right';
declare const createToastScope: CreateScope;
interface ToastProviderProps {
    children?: React.ReactNode;
    /**
     * An author-localized label for each toast. Used to help screen reader users
     * associate the interruption with a toast.
     * @defaultValue 'Notification'
     */
    label?: string;
    /**
     * Time in milliseconds that each toast should remain visible for.
     * @defaultValue 5000
     */
    duration?: number;
    /**
     * Direction of pointer swipe that should close the toast.
     * @defaultValue 'right'
     */
    swipeDirection?: SwipeDirection;
    /**
     * Distance in pixels that the swipe must pass before a close is triggered.
     * @defaultValue 50
     */
    swipeThreshold?: number;
    /**
     * An optional container where the toast announcements should be appended.
     * This is useful when working with focus traps or modal dialogs that make
     * other elements inert.
     * @defaultValue document.body
     */
    announcerContainer?: Element | DocumentFragment;
}
declare const ToastProvider: React.FC<ToastProviderProps>;
type PrimitiveOrderedListProps = React.ComponentPropsWithoutRef<typeof Primitive.ol>;
interface ToastViewportProps extends PrimitiveOrderedListProps {
    /**
     * The keys to use as the keyboard shortcut that will move focus to the toast viewport.
     * @defaultValue ['F8']
     */
    hotkey?: string[];
    /**
     * An author-localized label for the toast viewport to provide context for screen reader users
     * when navigating page landmarks. The available `{hotkey}` placeholder will be replaced for you.
     * @defaultValue 'Notifications ({hotkey})'
     */
    label?: string;
}
declare const ToastViewport: React.ForwardRefExoticComponent<ToastViewportProps & React.RefAttributes<HTMLOListElement>>;
type ToastElement = ToastImplElement;
interface ToastProps extends Omit<ToastImplProps, keyof ToastImplPrivateProps> {
    open?: boolean;
    defaultOpen?: boolean;
    onOpenChange?(open: boolean): void;
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: true;
}
declare const Toast: React.ForwardRefExoticComponent<ToastProps & React.RefAttributes<HTMLLIElement>>;
type SwipeEvent = {
    currentTarget: EventTarget & ToastElement;
} & Omit<CustomEvent<{
    originalEvent: React.PointerEvent;
    delta: {
        x: number;
        y: number;
    };
}>, 'currentTarget'>;
type ToastImplElement = React.ComponentRef<typeof Primitive.li>;
type DismissableLayerProps$1 = React.ComponentPropsWithoutRef<typeof Root$m>;
type ToastImplPrivateProps = {
    open: boolean;
    onClose(): void;
};
type PrimitiveListItemProps = React.ComponentPropsWithoutRef<typeof Primitive.li>;
interface ToastImplProps extends ToastImplPrivateProps, PrimitiveListItemProps {
    type?: 'foreground' | 'background';
    /**
     * Time in milliseconds that toast should remain visible for. Overrides value
     * given to `ToastProvider`.
     */
    duration?: number;
    onEscapeKeyDown?: DismissableLayerProps$1['onEscapeKeyDown'];
    onPause?(): void;
    onResume?(): void;
    onSwipeStart?(event: SwipeEvent): void;
    onSwipeMove?(event: SwipeEvent): void;
    onSwipeCancel?(event: SwipeEvent): void;
    onSwipeEnd?(event: SwipeEvent): void;
}
type PrimitiveDivProps$2 = React.ComponentPropsWithoutRef<typeof Primitive.div>;
interface ToastTitleProps extends PrimitiveDivProps$2 {
}
declare const ToastTitle: React.ForwardRefExoticComponent<ToastTitleProps & React.RefAttributes<HTMLDivElement>>;
interface ToastDescriptionProps extends PrimitiveDivProps$2 {
}
declare const ToastDescription: React.ForwardRefExoticComponent<ToastDescriptionProps & React.RefAttributes<HTMLDivElement>>;
interface ToastActionProps extends ToastCloseProps {
    /**
     * A short description for an alternate way to carry out the action. For screen reader users
     * who will not be able to navigate to the button easily/quickly.
     * @example <ToastAction altText="Goto account settings to upgrade">Upgrade</ToastAction>
     * @example <ToastAction altText="Undo (Alt+U)">Undo</ToastAction>
     */
    altText: string;
}
declare const ToastAction: React.ForwardRefExoticComponent<ToastActionProps & React.RefAttributes<HTMLButtonElement>>;
type PrimitiveButtonProps$3 = React.ComponentPropsWithoutRef<typeof Primitive.button>;
interface ToastCloseProps extends PrimitiveButtonProps$3 {
}
declare const ToastClose: React.ForwardRefExoticComponent<ToastCloseProps & React.RefAttributes<HTMLButtonElement>>;
declare const Provider$1: React.FC<ToastProviderProps>;
declare const Viewport: React.ForwardRefExoticComponent<ToastViewportProps & React.RefAttributes<HTMLOListElement>>;
declare const Root$3: React.ForwardRefExoticComponent<ToastProps & React.RefAttributes<HTMLLIElement>>;
declare const Title: React.ForwardRefExoticComponent<ToastTitleProps & React.RefAttributes<HTMLDivElement>>;
declare const Description: 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 index_d$4_Action: typeof Action;
declare const index_d$4_Close: typeof Close;
declare const index_d$4_Description: typeof Description;
declare const index_d$4_Title: typeof Title;
declare const index_d$4_Toast: typeof Toast;
declare const index_d$4_ToastAction: typeof ToastAction;
type index_d$4_ToastActionProps = ToastActionProps;
declare const index_d$4_ToastClose: typeof ToastClose;
type index_d$4_ToastCloseProps = ToastCloseProps;
declare const index_d$4_ToastDescription: typeof ToastDescription;
type index_d$4_ToastDescriptionProps = ToastDescriptionProps;
type index_d$4_ToastProps = ToastProps;
declare const index_d$4_ToastProvider: typeof ToastProvider;
type index_d$4_ToastProviderProps = ToastProviderProps;
declare const index_d$4_ToastTitle: typeof ToastTitle;
type index_d$4_ToastTitleProps = ToastTitleProps;
declare const index_d$4_ToastViewport: typeof ToastViewport;
type index_d$4_ToastViewportProps = ToastViewportProps;
declare const index_d$4_Viewport: typeof Viewport;
declare const index_d$4_createToastScope: typeof createToastScope;
declare namespace index_d$4 {
  export { index_d$4_Action as Action, index_d$4_Close as Close, index_d$4_Description as Description, Provider$1 as Provider, Root$3 as Root, index_d$4_Title as Title, index_d$4_Toast as Toast, index_d$4_ToastAction as ToastAction, index_d$4_ToastClose as ToastClose, index_d$4_ToastDescription as ToastDescription, index_d$4_ToastProvider as ToastProvider, index_d$4_ToastTitle as ToastTitle, index_d$4_ToastViewport as ToastViewport, index_d$4_Viewport as Viewport, index_d$4_createToastScope as createToastScope };
  export type { index_d$4_ToastActionProps as ToastActionProps, index_d$4_ToastCloseProps as ToastCloseProps, index_d$4_ToastDescriptionProps as ToastDescriptionProps, index_d$4_ToastProps as ToastProps, index_d$4_ToastProviderProps as ToastProviderProps, index_d$4_ToastTitleProps as ToastTitleProps, index_d$4_ToastViewportProps as ToastViewportProps };
}

type PrimitiveButtonProps$2 = React.ComponentPropsWithoutRef<typeof Primitive.button>;
interface ToggleProps$1 extends PrimitiveButtonProps$2 {
    /**
     * The controlled state of the toggle.
     */
    pressed?: boolean;
    /**
     * The state of the toggle when initially rendered. Use `defaultPressed`
     * if you do not need to control the state of the toggle.
     * @defaultValue false
     */
    defaultPressed?: boolean;
    /**
     * The callback that fires when the state of the toggle changes.
     */
    onPressedChange?(pressed: boolean): void;
}
declare const Toggle: React.ForwardRefExoticComponent<ToggleProps$1 & React.RefAttributes<HTMLButtonElement>>;
declare const Root$2: React.ForwardRefExoticComponent<ToggleProps$1 & React.RefAttributes<HTMLButtonElement>>;

declare const index_d$3_Toggle: typeof Toggle;
declare namespace index_d$3 {
  export { Root$2 as Root, index_d$3_Toggle as Toggle };
  export type { ToggleProps$1 as ToggleProps };
}

declare const createToggleGroupScope: CreateScope;
interface ToggleGroupSingleProps extends ToggleGroupImplSingleProps {
    type: 'single';
}
interface ToggleGroupMultipleProps extends ToggleGroupImplMultipleProps {
    type: 'multiple';
}
declare const ToggleGroup$1: React.ForwardRefExoticComponent<(ToggleGroupSingleProps | ToggleGroupMultipleProps) & React.RefAttributes<HTMLDivElement>>;
interface ToggleGroupImplSingleProps extends ToggleGroupImplProps {
    /**
     * The controlled stateful value of the item that is pressed.
     */
    value?: string;
    /**
     * The value of the item that is pressed when initially rendered. Use
     * `defaultValue` if you do not need to control the state of a toggle group.
     */
    defaultValue?: string;
    /**
     * The callback that fires when the value of the toggle group changes.
     */
    onValueChange?(value: string): void;
}
interface ToggleGroupImplMultipleProps extends ToggleGroupImplProps {
    /**
     * The controlled stateful value of the items that are pressed.
     */
    value?: string[];
    /**
     * The value of the items that are pressed when initially rendered. Use
     * `defaultValue` if you do not need to control the state of a toggle group.
     */
    defaultValue?: string[];
    /**
     * The callback that fires when the state of the toggle group changes.
     */
    onValueChange?(value: string[]): void;
}
type RovingFocusGroupProps$1 = React.ComponentPropsWithoutRef<typeof Root$h>;
type PrimitiveDivProps$1 = React.ComponentPropsWithoutRef<typeof Primitive.div>;
interface ToggleGroupImplProps extends PrimitiveDivProps$1 {
    /**
     * Whether the group is disabled from user interaction.
     * @defaultValue false
     */
    disabled?: boolean;
    /**
     * Whether the group should maintain roving focus of its buttons.
     * @defaultValue true
     */
    rovingFocus?: boolean;
    loop?: RovingFocusGroupProps$1['loop'];
    orientation?: RovingFocusGroupProps$1['orientation'];
    dir?: RovingFocusGroupProps$1['dir'];
}
interface ToggleGroupItemProps$1 extends Omit<ToggleGroupItemImplProps, 'pressed'> {
}
declare const ToggleGroupItem: React.ForwardRefExoticComponent<ToggleGroupItemProps$1 & React.RefAttributes<HTMLButtonElement>>;
type ToggleProps = React.ComponentPropsWithoutRef<typeof Toggle>;
interface ToggleGroupItemImplProps extends Omit<ToggleProps, 'defaultPressed' | 'onPressedChange'> {
    /**
     * A string value for the toggle group item. All items within a toggle group should use a unique value.
     */
    value: string;
}

declare const index_d$2_ToggleGroupItem: typeof ToggleGroupItem;
type index_d$2_ToggleGroupMultipleProps = ToggleGroupMultipleProps;
type index_d$2_ToggleGroupSingleProps = ToggleGroupSingleProps;
declare const index_d$2_createToggleGroupScope: typeof createToggleGroupScope;
declare namespace index_d$2 {
  export { ToggleGroupItem as Item, ToggleGroup$1 as Root, ToggleGroup$1 as ToggleGroup, index_d$2_ToggleGroupItem as ToggleGroupItem, index_d$2_createToggleGroupScope as createToggleGroupScope };
  export type { ToggleGroupItemProps$1 as ToggleGroupItemProps, index_d$2_ToggleGroupMultipleProps as ToggleGroupMultipleProps, index_d$2_ToggleGroupSingleProps as ToggleGroupSingleProps };
}

declare const createToolbarScope: CreateScope;
type RovingFocusGroupProps = React.ComponentPropsWithoutRef<typeof Root$h>;
type PrimitiveDivProps = React.ComponentPropsWithoutRef<typeof Primitive.div>;
interface ToolbarProps extends PrimitiveDivProps {
    orientation?: RovingFocusGroupProps['orientation'];
    loop?: RovingFocusGroupProps['loop'];
    dir?: RovingFocusGroupProps['dir'];
}
declare const Toolbar: React.ForwardRefExoticComponent<ToolbarProps & React.RefAttributes<HTMLDivElement>>;
type SeparatorProps = React.ComponentPropsWithoutRef<typeof Root$5>;
interface ToolbarSeparatorProps extends SeparatorProps {
}
declare const ToolbarSeparator: React.ForwardRefExoticComponent<ToolbarSeparatorProps & React.RefAttributes<HTMLDivElement>>;
type PrimitiveButtonProps$1 = React.ComponentPropsWithoutRef<typeof Primitive.button>;
interface ToolbarButtonProps extends PrimitiveButtonProps$1 {
}
declare const ToolbarButton: React.ForwardRefExoticComponent<ToolbarButtonProps & React.RefAttributes<HTMLButtonElement>>;
type PrimitiveLinkProps = React.ComponentPropsWithoutRef<typeof Primitive.a>;
interface ToolbarLinkProps extends PrimitiveLinkProps {
}
declare const ToolbarLink: React.ForwardRefExoticComponent<ToolbarLinkProps & React.RefAttributes<HTMLAnchorElement>>;
type ToggleGroupProps = React.ComponentPropsWithoutRef<typeof ToggleGroup$1>;
interface ToolbarToggleGroupSingleProps extends Extract<ToggleGroupProps, {
    type: 'single';
}> {
}
interface ToolbarToggleGroupMultipleProps extends Extract<ToggleGroupProps, {
    type: 'multiple';
}> {
}
declare const ToolbarToggleGroup: React.ForwardRefExoticComponent<(ToolbarToggleGroupSingleProps | ToolbarToggleGroupMultipleProps) & React.RefAttributes<HTMLDivElement>>;
type ToggleGroupItemProps = React.ComponentPropsWithoutRef<typeof ToggleGroupItem>;
interface ToolbarToggleItemProps extends ToggleGroupItemProps {
}
declare const ToolbarToggleItem: React.ForwardRefExoticComponent<ToolbarToggleItemProps & React.RefAttributes<HTMLButtonElement>>;
declare const Root$1: React.ForwardRefExoticComponent<ToolbarProps & React.RefAttributes<HTMLDivElement>>;
declare const Separator: React.ForwardRefExoticComponent<ToolbarSeparatorProps & React.RefAttributes<HTMLDivElement>>;
declare const Button: React.ForwardRefExoticComponent<ToolbarButtonProps & React.RefAttributes<HTMLButtonElement>>;
declare const Link: React.ForwardRefExoticComponent<ToolbarLinkProps & React.RefAttributes<HTMLAnchorElement>>;
declare const ToggleGroup: React.ForwardRefExoticComponent<(ToolbarToggleGroupSingleProps | ToolbarToggleGroupMultipleProps) & React.RefAttributes<HTMLDivElement>>;
declare const ToggleItem: React.ForwardRefExoticComponent<ToolbarToggleItemProps & React.RefAttributes<HTMLButtonElement>>;

declare const index_d$1_Button: typeof Button;
declare const index_d$1_Link: typeof Link;
declare const index_d$1_Separator: typeof Separator;
declare const index_d$1_ToggleGroup: typeof ToggleGroup;
declare const index_d$1_ToggleItem: typeof ToggleItem;
declare const index_d$1_Toolbar: typeof Toolbar;
declare const index_d$1_ToolbarButton: typeof ToolbarButton;
type index_d$1_ToolbarButtonProps = ToolbarButtonProps;
declare const index_d$1_ToolbarLink: typeof ToolbarLink;
type index_d$1_ToolbarLinkProps = ToolbarLinkProps;
type index_d$1_ToolbarProps = ToolbarProps;
declare const index_d$1_ToolbarSeparator: typeof ToolbarSeparator;
type index_d$1_ToolbarSeparatorProps = ToolbarSeparatorProps;
declare const index_d$1_ToolbarToggleGroup: typeof ToolbarToggleGroup;
type index_d$1_ToolbarToggleGroupMultipleProps = ToolbarToggleGroupMultipleProps;
type index_d$1_ToolbarToggleGroupSingleProps = ToolbarToggleGroupSingleProps;
declare const index_d$1_ToolbarToggleItem: typeof ToolbarToggleItem;
type index_d$1_ToolbarToggleItemProps = ToolbarToggleItemProps;
declare const index_d$1_createToolbarScope: typeof createToolbarScope;
declare namespace index_d$1 {
  export { index_d$1_Button as Button, index_d$1_Link as Link, Root$1 as Root, index_d$1_Separator as Separator, index_d$1_ToggleGroup as ToggleGroup, index_d$1_ToggleItem as ToggleItem, index_d$1_Toolbar as Toolbar, index_d$1_ToolbarButton as ToolbarButton, index_d$1_ToolbarLink as ToolbarLink, index_d$1_ToolbarSeparator as ToolbarSeparator, index_d$1_ToolbarToggleGroup as ToolbarToggleGroup, index_d$1_ToolbarToggleItem as ToolbarToggleItem, index_d$1_createToolbarScope as createToolbarScope };
  export type { index_d$1_ToolbarButtonProps as ToolbarButtonProps, index_d$1_ToolbarLinkProps as ToolbarLinkProps, index_d$1_ToolbarProps as ToolbarProps, index_d$1_ToolbarSeparatorProps as ToolbarSeparatorProps, index_d$1_ToolbarToggleGroupMultipleProps as ToolbarToggleGroupMultipleProps, index_d$1_ToolbarToggleGroupSingleProps as ToolbarToggleGroupSingleProps, index_d$1_ToolbarToggleItemProps as ToolbarToggleItemProps };
}

declare const createTooltipScope: CreateScope;
interface TooltipProviderProps {
    children: React.ReactNode;
    /**
     * The duration from when the pointer enters the trigger until the tooltip gets opened.
     * @defaultValue 700
     */
    delayDuration?: number;
    /**
     * How much time a user has to enter another trigger without incurring a delay again.
     * @defaultValue 300
     */
    skipDelayDuration?: number;
    /**
     * When `true`, trying to hover the content will result in the tooltip closing as the pointer leaves the trigger.
     * @defaultValue false
     */
    disableHoverableContent?: boolean;
}
declare const TooltipProvider: React.FC<TooltipProviderProps>;
interface TooltipProps {
    children?: React.ReactNode;
    open?: boolean;
    defaultOpen?: boolean;
    onOpenChange?: (open: boolean) => void;
    /**
     * The duration from when the pointer enters the trigger until the tooltip gets opened. This will
     * override the prop with the same name passed to Provider.
     * @defaultValue 700
     */
    delayDuration?: number;
    /**
     * When `true`, trying to hover the content will result in the tooltip closing as the pointer leaves the trigger.
     * @defaultValue false
     */
    disableHoverableContent?: boolean;
}
declare const Tooltip: React.FC<TooltipProps>;
type PrimitiveButtonProps = React.ComponentPropsWithoutRef<typeof Primitive.button>;
interface TooltipTriggerProps extends PrimitiveButtonProps {
}
declare const TooltipTrigger: React.ForwardRefExoticComponent<TooltipTriggerProps & React.RefAttributes<HTMLButtonElement>>;
type PortalProps = React.ComponentPropsWithoutRef<typeof Portal$8>;
interface TooltipPortalProps {
    children?: React.ReactNode;
    /**
     * Specify a container element to portal the content into.
     */
    container?: PortalProps['container'];
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: true;
}
declare const TooltipPortal: React.FC<TooltipPortalProps>;
interface TooltipContentProps extends TooltipContentImplProps {
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: true;
}
declare const TooltipContent: React.ForwardRefExoticComponent<TooltipContentProps & React.RefAttributes<HTMLDivElement>>;
type DismissableLayerProps = React.ComponentPropsWithoutRef<typeof DismissableLayer>;
type PopperContentProps = React.ComponentPropsWithoutRef<typeof Content$9>;
interface TooltipContentImplProps extends Omit<PopperContentProps, 'onPlaced'> {
    /**
     * A more descriptive label for accessibility purpose
     */
    'aria-label'?: string;
    /**
     * Event handler called when the escape key is down.
     * Can be prevented.
     */
    onEscapeKeyDown?: DismissableLayerProps['onEscapeKeyDown'];
    /**
     * Event handler called when the a `pointerdown` event happens outside of the `Tooltip`.
     * Can be prevented.
     */
    onPointerDownOutside?: DismissableLayerProps['onPointerDownOutside'];
}
type PopperArrowProps = React.ComponentPropsWithoutRef<typeof Arrow$7>;
interface TooltipArrowProps extends PopperArrowProps {
}
declare const TooltipArrow: React.ForwardRefExoticComponent<TooltipArrowProps & React.RefAttributes<SVGSVGElement>>;
declare const Provider: React.FC<TooltipProviderProps>;
declare const Root: React.FC<TooltipProps>;
declare const Trigger: React.ForwardRefExoticComponent<TooltipTriggerProps & React.RefAttributes<HTMLButtonElement>>;
declare const Portal: React.FC<TooltipPortalProps>;
declare const Content: React.ForwardRefExoticComponent<TooltipContentProps & React.RefAttributes<HTMLDivElement>>;
declare const Arrow: React.ForwardRefExoticComponent<TooltipArrowProps & React.RefAttributes<SVGSVGElement>>;

declare const index_d_Arrow: typeof Arrow;
declare const index_d_Content: typeof Content;
declare const index_d_Portal: typeof Portal;
declare const index_d_Provider: typeof Provider;
declare const index_d_Root: typeof Root;
declare const index_d_Tooltip: typeof Tooltip;
declare const index_d_TooltipArrow: typeof TooltipArrow;
type index_d_TooltipArrowProps = TooltipArrowProps;
declare const index_d_TooltipContent: typeof TooltipContent;
type index_d_TooltipContentProps = TooltipContentProps;
declare const index_d_TooltipPortal: typeof TooltipPortal;
type index_d_TooltipPortalProps = TooltipPortalProps;
type index_d_TooltipProps = TooltipProps;
declare const index_d_TooltipProvider: typeof TooltipProvider;
type index_d_TooltipProviderProps = TooltipProviderProps;
declare const index_d_TooltipTrigger: typeof TooltipTrigger;
type index_d_TooltipTriggerProps = TooltipTriggerProps;
declare const index_d_Trigger: typeof Trigger;
declare const index_d_createTooltipScope: typeof createTooltipScope;
declare namespace index_d {
  export { index_d_Arrow as Arrow, index_d_Content as Content, index_d_Portal as Portal, index_d_Provider as Provider, index_d_Root as Root, index_d_Tooltip as Tooltip, index_d_TooltipArrow as TooltipArrow, index_d_TooltipContent as TooltipContent, index_d_TooltipPortal as TooltipPortal, index_d_TooltipProvider as TooltipProvider, index_d_TooltipTrigger as TooltipTrigger, index_d_Trigger as Trigger, index_d_createTooltipScope as createTooltipScope };
  export type { index_d_TooltipArrowProps as TooltipArrowProps, index_d_TooltipContentProps as TooltipContentProps, index_d_TooltipPortalProps as TooltipPortalProps, index_d_TooltipProps as TooltipProps, index_d_TooltipProviderProps as TooltipProviderProps, index_d_TooltipTriggerProps as TooltipTriggerProps };
}

export { index_d$y as AccessibleIcon, index_d$w as Accordion, index_d$t as AlertDialog, index_d$s as AspectRatio, index_d$r as Avatar, index_d$q as Checkbox, index_d$x as Collapsible, index_d$p as ContextMenu, index_d$u as Dialog, index_d$o as Direction, index_d$n as DropdownMenu, index_d$l as Form, index_d$k as HoverCard, index_d$m as Label, index_d$j as Menubar, index_d$h as NavigationMenu, index_d$e as Popover, index_d$v as Portal, index_d$d as Progress, index_d$c as RadioGroup, index_d$b as ScrollArea, index_d$a as Select, index_d$9 as Separator, index_d$8 as Slider, index_d$7 as Slot, index_d$6 as Switch, index_d$5 as Tabs, index_d$4 as Toast, index_d$3 as Toggle, index_d$2 as ToggleGroup, index_d$1 as Toolbar, index_d as Tooltip, index_d$i as VisuallyHidden, index_d$g as unstable_OneTimePasswordField, index_d$f as unstable_PasswordToggleField };