@optiaxiom/web-components 0.8.2 → 0.8.3

package/dist/index.d-BoWVRvQI.d.ts

@@ -0,0 +1,1948 @@
+import * as react from 'react';
+import react__default, { ReactElement, RefObject, ReactNode, ComponentPropsWithoutRef, ComponentPropsWithRef } from 'react';
+import { b as Primitive$1, c as Close, d as Description, e as Content$5, f as Trigger, R as Root$3, g as Content$6, h as DismissableLayer, F as FocusScope, S as Sprinkles, E as ExcludeProps, i as BoxProps, j as RecipeVariants, k as ExtendProps, l as DialogCloseProps$1, m as DialogTriggerProps$1, T as Transition, n as Root$4, o as DialogContentProps$1, p as DialogDescriptionProps$1, q as DialogTitleProps, M as MenuListbox, r as ResponsiveArray, s as PopoverAnchorProps, t as PopoverTriggerProps } from './PopoverContent-BG1q2SMH.d-Cm7Is13w.js';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+
+type PrimitiveDivProps$8 = react.ComponentPropsWithoutRef<typeof Primitive$1.div>;
+interface PortalProps extends PrimitiveDivProps$8 {
+    /**
+     * An optional container where the portaled content should be appended.
+     */
+    container?: Element | DocumentFragment | null;
+}
+declare const Portal: react.ForwardRefExoticComponent<PortalProps & react.RefAttributes<HTMLDivElement>>;
+
+type DialogTriggerProps = react.ComponentPropsWithoutRef<typeof Trigger>;
+interface AlertDialogTriggerProps extends DialogTriggerProps {
+}
+type DialogContentProps = react.ComponentPropsWithoutRef<typeof Content$5>;
+interface AlertDialogContentProps$1 extends Omit<DialogContentProps, 'onPointerDownOutside' | 'onInteractOutside'> {
+}
+type DialogDescriptionProps = react.ComponentPropsWithoutRef<typeof Description>;
+interface AlertDialogDescriptionProps extends DialogDescriptionProps {
+}
+type DialogCloseProps = react.ComponentPropsWithoutRef<typeof Close>;
+interface AlertDialogActionProps extends DialogCloseProps {
+}
+interface AlertDialogCancelProps extends DialogCloseProps {
+}
+declare const Content$4: react.ForwardRefExoticComponent<AlertDialogContentProps$1 & react.RefAttributes<HTMLDivElement>>;
+
+type ToastItem = {
+    id: string;
+    open: boolean;
+    ref: RefObject<HTMLElement>;
+    toast: ReactElement | (ToastOptions & {
+        title: string;
+    });
+};
+type ToastOptions = {
+    action?: string;
+    onAction?: () => void;
+    type?: "danger" | "information" | "neutral" | "success" | "warning";
+};
+type Toaster = {
+    clear: () => void;
+    create: (...args: [message: string, options?: ToastOptions] | [toast: ReactElement]) => string;
+    remove: (id: string) => void;
+    store: [
+        subscribe: (onStoreChange: () => void) => () => void,
+        getSnapshot: () => ToastItem[],
+        getServerSnapshot?: () => ToastItem[]
+    ];
+};
+declare const createToaster: () => Toaster;
+
+type SwipeDirection = 'up' | 'down' | 'left' | 'right';
+interface ToastProviderProps$1 {
+    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;
+}
+type PrimitiveOrderedListProps = react.ComponentPropsWithoutRef<typeof Primitive$1.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;
+}
+type ToastElement = ToastImplElement;
+interface ToastProps$1 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;
+}
+type SwipeEvent = {
+    currentTarget: EventTarget & ToastElement;
+} & Omit<CustomEvent<{
+    originalEvent: react.PointerEvent;
+    delta: {
+        x: number;
+        y: number;
+    };
+}>, 'currentTarget'>;
+type ToastImplElement = react.ElementRef<typeof Primitive$1.li>;
+type DismissableLayerProps$2 = react.ComponentPropsWithoutRef<typeof Root$3>;
+type ToastImplPrivateProps = {
+    open: boolean;
+    onClose(): void;
+};
+type PrimitiveListItemProps = react.ComponentPropsWithoutRef<typeof Primitive$1.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$2['onEscapeKeyDown'];
+    onPause?(): void;
+    onResume?(): void;
+    onSwipeStart?(event: SwipeEvent): void;
+    onSwipeMove?(event: SwipeEvent): void;
+    onSwipeCancel?(event: SwipeEvent): void;
+    onSwipeEnd?(event: SwipeEvent): void;
+}
+type PrimitiveDivProps$7 = react.ComponentPropsWithoutRef<typeof Primitive$1.div>;
+interface ToastTitleProps extends PrimitiveDivProps$7 {
+}
+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;
+}
+type PrimitiveButtonProps$3 = react.ComponentPropsWithoutRef<typeof Primitive$1.button>;
+interface ToastCloseProps extends PrimitiveButtonProps$3 {
+}
+declare const Root$2: react.ForwardRefExoticComponent<ToastProps$1 & react.RefAttributes<HTMLLIElement>>;
+
+interface TooltipProviderProps$2 {
+    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;
+}
+interface TooltipProps$1 {
+    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;
+}
+type PrimitiveButtonProps$2 = react.ComponentPropsWithoutRef<typeof Primitive$1.button>;
+interface TooltipTriggerProps extends PrimitiveButtonProps$2 {
+}
+interface TooltipContentProps$1 extends TooltipContentImplProps {
+    /**
+     * Used to force mounting when more control is needed. Useful when
+     * controlling animation with React animation libraries.
+     */
+    forceMount?: true;
+}
+type DismissableLayerProps$1 = react.ComponentPropsWithoutRef<typeof DismissableLayer>;
+type PopperContentProps$1 = react.ComponentPropsWithoutRef<typeof Content$6>;
+interface TooltipContentImplProps extends Omit<PopperContentProps$1, '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$1['onEscapeKeyDown'];
+    /**
+     * Event handler called when the a `pointerdown` event happens outside of the `Tooltip`.
+     * Can be prevented.
+     */
+    onPointerDownOutside?: DismissableLayerProps$1['onPointerDownOutside'];
+}
+declare const Provider: react.FC<TooltipProviderProps$2>;
+declare const Root$1: react.FC<TooltipProps$1>;
+declare const Content$3: react.ForwardRefExoticComponent<TooltipContentProps$1 & react.RefAttributes<HTMLDivElement>>;
+
+type PrimitiveDivProps$6 = react.ComponentPropsWithoutRef<typeof Primitive$1.div>;
+interface CollapsibleProps extends PrimitiveDivProps$6 {
+    defaultOpen?: boolean;
+    open?: boolean;
+    disabled?: boolean;
+    onOpenChange?(open: boolean): void;
+}
+interface CollapsibleContentProps extends Omit<CollapsibleContentImplProps, 'present'> {
+    /**
+     * Used to force mounting when more control is needed. Useful when
+     * controlling animation with React animation libraries.
+     */
+    forceMount?: true;
+}
+interface CollapsibleContentImplProps extends PrimitiveDivProps$6 {
+    present: boolean;
+}
+declare const Content$2: react.ForwardRefExoticComponent<CollapsibleContentProps & react.RefAttributes<HTMLDivElement>>;
+
+declare const NODES: readonly ["a", "button", "div", "form", "h2", "h3", "img", "input", "label", "li", "nav", "ol", "p", "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;
+
+type Orientation$1 = react.AriaAttributes['aria-orientation'];
+type Direction = 'ltr' | 'rtl';
+interface RovingFocusGroupOptions {
+    /**
+     * The orientation of the group.
+     * Mainly so arrow navigation is done accordingly (left & right vs. up & down)
+     */
+    orientation?: Orientation$1;
+    /**
+     * The direction of navigation between items.
+     */
+    dir?: Direction;
+    /**
+     * Whether keyboard navigation should loop around
+     * @defaultValue false
+     */
+    loop?: boolean;
+}
+interface RovingFocusGroupProps$3 extends RovingFocusGroupImplProps {
+}
+type PrimitiveDivProps$5 = react.ComponentPropsWithoutRef<typeof Primitive.div>;
+interface RovingFocusGroupImplProps extends Omit<PrimitiveDivProps$5, 'dir'>, RovingFocusGroupOptions {
+    currentTabStopId?: string | null;
+    defaultCurrentTabStopId?: string;
+    onCurrentTabStopIdChange?: (tabStopId: string | null) => void;
+    onEntryFocus?: (event: Event) => void;
+    preventScrollOnEntryFocus?: boolean;
+}
+declare const Root: react.ForwardRefExoticComponent<RovingFocusGroupProps$3 & react.RefAttributes<HTMLDivElement>>;
+
+/**
+ * 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$1 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 = react.ComponentPropsWithoutRef<typeof FocusScope>;
+type DismissableLayerProps = react.ComponentPropsWithoutRef<typeof DismissableLayer>;
+type RovingFocusGroupProps$2 = react.ComponentPropsWithoutRef<typeof Root>;
+type PopperContentProps = react.ComponentPropsWithoutRef<typeof Content$6>;
+type MenuContentImplPrivateProps = {
+    onOpenAutoFocus?: FocusScopeProps['onMountAutoFocus'];
+    onDismiss?: DismissableLayerProps['onDismiss'];
+    disableOutsidePointerEvents?: DismissableLayerProps['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['trapped'];
+};
+interface MenuContentImplProps extends MenuContentImplPrivateProps, Omit<PopperContentProps, 'dir' | 'onPlaced'> {
+    /**
+     * Event handler called when auto-focusing on close.
+     * Can be prevented.
+     */
+    onCloseAutoFocus?: FocusScopeProps['onUnmountAutoFocus'];
+    /**
+     * Whether keyboard navigation should loop around
+     * @defaultValue false
+     */
+    loop?: RovingFocusGroupProps$2['loop'];
+    onEntryFocus?: RovingFocusGroupProps$2['onEntryFocus'];
+    onEscapeKeyDown?: DismissableLayerProps['onEscapeKeyDown'];
+    onPointerDownOutside?: DismissableLayerProps['onPointerDownOutside'];
+    onFocusOutside?: DismissableLayerProps['onFocusOutside'];
+    onInteractOutside?: DismissableLayerProps['onInteractOutside'];
+}
+type PrimitiveDivProps$4 = react.ComponentPropsWithoutRef<typeof Primitive$1.div>;
+interface MenuGroupProps$1 extends PrimitiveDivProps$4 {
+}
+interface MenuLabelProps$1 extends PrimitiveDivProps$4 {
+}
+interface MenuItemProps$1 extends Omit<MenuItemImplProps, 'onSelect'> {
+    onSelect?: (event: Event) => void;
+}
+interface MenuItemImplProps extends PrimitiveDivProps$4 {
+    disabled?: boolean;
+    textValue?: string;
+}
+type CheckedState = boolean | 'indeterminate';
+interface MenuCheckboxItemProps$1 extends MenuItemProps$1 {
+    checked?: CheckedState;
+    onCheckedChange?: (checked: boolean) => void;
+}
+interface MenuSeparatorProps$1 extends PrimitiveDivProps$4 {
+}
+interface MenuSubContentProps$2 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;
+}
+declare const Content$1: react.ForwardRefExoticComponent<MenuContentProps$1 & react.RefAttributes<HTMLDivElement>>;
+declare const Group: react.ForwardRefExoticComponent<MenuGroupProps$1 & react.RefAttributes<HTMLDivElement>>;
+declare const Label: react.ForwardRefExoticComponent<MenuLabelProps$1 & react.RefAttributes<HTMLDivElement>>;
+declare const Item: react.ForwardRefExoticComponent<MenuItemProps$1 & react.RefAttributes<HTMLDivElement>>;
+declare const CheckboxItem: react.ForwardRefExoticComponent<MenuCheckboxItemProps$1 & react.RefAttributes<HTMLDivElement>>;
+declare const Separator$1: react.ForwardRefExoticComponent<MenuSeparatorProps$1 & react.RefAttributes<HTMLDivElement>>;
+declare const SubContent$1: react.ForwardRefExoticComponent<MenuSubContentProps$2 & react.RefAttributes<HTMLDivElement>>;
+
+type MenuContentProps = react.ComponentPropsWithoutRef<typeof Content$1>;
+interface DropdownMenuContentProps$1 extends Omit<MenuContentProps, 'onEntryFocus'> {
+}
+type MenuGroupProps = react.ComponentPropsWithoutRef<typeof Group>;
+interface DropdownMenuGroupProps extends MenuGroupProps {
+}
+type MenuLabelProps = react.ComponentPropsWithoutRef<typeof Label>;
+interface DropdownMenuLabelProps extends MenuLabelProps {
+}
+type MenuItemProps = react.ComponentPropsWithoutRef<typeof Item>;
+interface DropdownMenuItemProps extends MenuItemProps {
+}
+type MenuCheckboxItemProps = react.ComponentPropsWithoutRef<typeof CheckboxItem>;
+interface DropdownMenuCheckboxItemProps extends MenuCheckboxItemProps {
+}
+type MenuSeparatorProps = react.ComponentPropsWithoutRef<typeof Separator$1>;
+interface DropdownMenuSeparatorProps extends MenuSeparatorProps {
+}
+type MenuSubContentProps$1 = react.ComponentPropsWithoutRef<typeof SubContent$1>;
+interface DropdownMenuSubContentProps extends MenuSubContentProps$1 {
+}
+declare const Content: react.ForwardRefExoticComponent<DropdownMenuContentProps$1 & react.RefAttributes<HTMLDivElement>>;
+declare const SubContent: react.ForwardRefExoticComponent<DropdownMenuSubContentProps & react.RefAttributes<HTMLDivElement>>;
+
+declare const ORIENTATIONS: readonly ["horizontal", "vertical"];
+type Orientation = (typeof ORIENTATIONS)[number];
+type PrimitiveDivProps$3 = react.ComponentPropsWithoutRef<typeof Primitive$1.div>;
+interface SeparatorProps extends PrimitiveDivProps$3 {
+    /**
+     * 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;
+}
+
+type PrimitiveDivProps$2 = react.ComponentPropsWithoutRef<typeof Primitive$1.div>;
+interface ProgressProps extends PrimitiveDivProps$2 {
+    value?: number | null | undefined;
+    max?: number;
+    getValueLabel?(value: number, max: number): string;
+}
+
+type PrimitiveButtonProps$1 = react.ComponentPropsWithoutRef<typeof Primitive$1.button>;
+interface ToggleProps$1 extends PrimitiveButtonProps$1 {
+    /**
+     * 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>>;
+
+interface ToggleGroupSingleProps extends ToggleGroupImplSingleProps {
+    type: 'single';
+}
+interface ToggleGroupMultipleProps extends ToggleGroupImplMultipleProps {
+    type: 'multiple';
+}
+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__default.ComponentPropsWithoutRef<typeof Root>;
+type PrimitiveDivProps$1 = react__default.ComponentPropsWithoutRef<typeof Primitive$1.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 extends Omit<ToggleGroupItemImplProps, 'pressed'> {
+}
+type ToggleProps = react__default.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;
+}
+
+type RovingFocusGroupProps = react.ComponentPropsWithoutRef<typeof Root>;
+type PrimitiveDivProps = react.ComponentPropsWithoutRef<typeof Primitive$1.div>;
+interface TabsProps extends PrimitiveDivProps {
+    /** 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['orientation'];
+    /**
+     * The direction of navigation between toolbar items.
+     */
+    dir?: RovingFocusGroupProps['dir'];
+    /**
+     * Whether a tab is activated automatically or manually.
+     * @defaultValue automatic
+     * */
+    activationMode?: 'automatic' | 'manual';
+}
+interface TabsListProps extends PrimitiveDivProps {
+    loop?: RovingFocusGroupProps['loop'];
+}
+type PrimitiveButtonProps = react.ComponentPropsWithoutRef<typeof Primitive$1.button>;
+interface TabsTriggerProps extends PrimitiveButtonProps {
+    value: string;
+}
+interface TabsContentProps$1 extends PrimitiveDivProps {
+    value: string;
+    /**
+     * Used to force mounting when more control is needed. Useful when
+     * controlling animation with React animation libraries.
+     */
+    forceMount?: true;
+}
+declare const TabsContent$1: react.ForwardRefExoticComponent<TabsContentProps$1 & react.RefAttributes<HTMLDivElement>>;
+
+declare const Alert: react.ForwardRefExoticComponent<{
+    intent?: "information" | "success" | "warning" | "danger" | "neutral" | undefined;
+} & {
+    /**
+     * Show a close button inside the alert and invoke this callback when the close button is clicked.
+     */
+    onDismiss?: () => void;
+} & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLDivElement>>;
+
+type AlertDialogProps = {
+    children?: React.ReactNode;
+    /**
+     * The initial open state in uncontrolled mode.
+     */
+    defaultOpen?: boolean;
+    /**
+     * Handler that is called when the open state changes.
+     */
+    onOpenChange?: (open: boolean) => void;
+    /**
+     * The open state in controlled mode.
+     */
+    open?: boolean;
+};
+declare function AlertDialog({ children, defaultOpen, onOpenChange, open: openProp, ...props }: AlertDialogProps): react_jsx_runtime.JSX.Element;
+declare namespace AlertDialog {
+    var displayName: string;
+}
+
+declare const AlertDialogAction: react.ForwardRefExoticComponent<Omit<{
+    addonAfter?: react.ReactNode;
+    addonBefore?: react.ReactNode;
+    icon?: react.ReactNode;
+    iconPosition?: "end" | "start";
+}, never> & Omit<NonNullable<Omit<{
+    intent?: "danger" | "neutral" | "primary" | undefined;
+    size?: "sm" | "md" | "lg" | undefined;
+    square?: boolean | undefined;
+    variant?: "strong" | "outline" | "subtle" | undefined;
+}, "intent" | "variant"> & {
+    appearance?: "default" | "danger" | "primary" | "subtle" | "inverse" | "danger-outline";
+    disabled?: boolean;
+    loading?: boolean;
+}>, never> & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, "size"> & Omit<Omit<AlertDialogActionProps & react.RefAttributes<HTMLButtonElement>, "ref">, "asChild" | "color" | "disabled" | "className"> & react.RefAttributes<HTMLButtonElement>>;
+
+declare const AlertDialogBody: react.ForwardRefExoticComponent<Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<AlertDialogDescriptionProps & react.RefAttributes<HTMLParagraphElement>, "ref">, "asChild" | "color" | "className"> & react.RefAttributes<HTMLDivElement>>;
+
+declare const AlertDialogCancel: react.ForwardRefExoticComponent<Omit<{
+    addonAfter?: react.ReactNode;
+    addonBefore?: react.ReactNode;
+    icon?: react.ReactNode;
+    iconPosition?: "end" | "start";
+}, never> & Omit<NonNullable<Omit<{
+    intent?: "danger" | "neutral" | "primary" | undefined;
+    size?: "sm" | "md" | "lg" | undefined;
+    square?: boolean | undefined;
+    variant?: "strong" | "outline" | "subtle" | undefined;
+}, "intent" | "variant"> & {
+    appearance?: "default" | "danger" | "primary" | "subtle" | "inverse" | "danger-outline";
+    disabled?: boolean;
+    loading?: boolean;
+}>, never> & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, "size"> & Omit<Omit<AlertDialogCancelProps & react.RefAttributes<HTMLButtonElement>, "ref">, "asChild" | "color" | "disabled" | "className"> & react.RefAttributes<HTMLButtonElement>>;
+
+declare const content: (props?: {
+    size?: "sm" | "md" | "lg" | undefined;
+} | undefined, className?: string) => {
+    className: string;
+};
+type DialogVariants = RecipeVariants<typeof content>;
+
+type AlertDialogContentProps = ExcludeProps<BoxProps<typeof Content$4, DialogVariants>, "forceMount">;
+declare const AlertDialogContent: react.ForwardRefExoticComponent<AlertDialogContentProps & react.RefAttributes<HTMLDivElement>>;
+
+declare const AlertDialogFooter: react.ForwardRefExoticComponent<Omit<Omit<Omit<Omit<Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLDivElement> | null | undefined;
+}, "ref"> & react.RefAttributes<HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLDivElement> | null | undefined;
+}, "ref"> & react.RefAttributes<HTMLDivElement>>;
+
+declare const AlertDialogHeader: react.ForwardRefExoticComponent<{
+    /**
+     * We show an alert icon before the title by default but this can be replaced with any other icon.
+     */
+    addonBefore?: ReactNode;
+} & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLHeadingElement>>;
+
+declare const AlertDialogTrigger: react.ForwardRefExoticComponent<Omit<{
+    addonAfter?: react.ReactNode;
+    addonBefore?: react.ReactNode;
+    icon?: react.ReactNode;
+    iconPosition?: "end" | "start";
+}, never> & Omit<NonNullable<Omit<{
+    intent?: "danger" | "neutral" | "primary" | undefined;
+    size?: "sm" | "md" | "lg" | undefined;
+    square?: boolean | undefined;
+    variant?: "strong" | "outline" | "subtle" | undefined;
+}, "intent" | "variant"> & {
+    appearance?: "default" | "danger" | "primary" | "subtle" | "inverse" | "danger-outline";
+    disabled?: boolean;
+    loading?: boolean;
+}>, never> & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, "size"> & Omit<Omit<AlertDialogTriggerProps & react.RefAttributes<HTMLButtonElement>, "ref">, "asChild" | "color" | "disabled" | "className"> & react.RefAttributes<HTMLButtonElement>>;
+
+declare const AngleMenuButton: react.ForwardRefExoticComponent<Omit<Omit<{
+    addonAfter?: react.ReactNode;
+    addonBefore?: react.ReactNode;
+    icon?: react.ReactNode;
+    iconPosition?: "end" | "start";
+}, never> & Omit<NonNullable<Omit<{
+    intent?: "danger" | "neutral" | "primary" | undefined;
+    size?: "sm" | "md" | "lg" | undefined;
+    square?: boolean | undefined;
+    variant?: "strong" | "outline" | "subtle" | undefined;
+}, "intent" | "variant"> & {
+    appearance?: "default" | "danger" | "primary" | "subtle" | "inverse" | "danger-outline";
+    disabled?: boolean;
+    loading?: boolean;
+}>, never> & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, "size"> & Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">, "color" | "disabled" | "className"> & react.RefAttributes<HTMLButtonElement>, "ref"> & react.RefAttributes<HTMLButtonElement>>;
+
+declare const mapFallbackToIcon: {
+    team: react_jsx_runtime.JSX.Element;
+    user: react_jsx_runtime.JSX.Element;
+};
+declare const Avatar: react.ForwardRefExoticComponent<{
+    colorScheme?: "neutral" | "purple" | undefined;
+    size?: "sm" | "md" | "xs" | "2xs" | "xl" | "3xl" | undefined;
+} & {
+    /**
+     * The fallback icon to display when no name or image is given.
+     */
+    fallback?: keyof typeof mapFallbackToIcon;
+    /**
+     * Use name to generate initials to show inside the avatar.
+     */
+    name?: string;
+    /**
+     * Render the image inside the avatar.
+     */
+    src?: string;
+} & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, "size"> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLSpanElement>>;
+
+declare const AvatarGroup: react.ForwardRefExoticComponent<{
+    /**
+     * Control the size of the avatars.
+     */
+    size?: ComponentPropsWithoutRef<typeof Avatar>["size"];
+} & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, "size"> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLDivElement>>;
+
+declare const ToastProvider: react.ForwardRefExoticComponent<ToastProviderProps$1 & {
+    position?: "bottom" | "top" | "bottom-left" | "bottom-right" | "top-left" | "top-right" | undefined;
+} & {
+    children?: never;
+    container?: ComponentPropsWithoutRef<typeof Portal>["container"];
+    /**
+     * An instance of toaster returned from the `createToaster` method.
+     */
+    toaster?: ReturnType<typeof createToaster>;
+} & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<ToastViewportProps & react.RefAttributes<HTMLOListElement>, "ref">, "asChild" | "children" | "label" | "color" | "className"> & react.RefAttributes<HTMLOListElement>>;
+
+type TooltipProviderProps$1 = ExtendProps<ComponentPropsWithoutRef<typeof Provider>, {
+    /**
+     * When `true`, trying to hover the content will result in the tooltip closing as the pointer leaves the trigger.
+     */
+    disableHoverableContent?: boolean;
+}>;
+declare function TooltipProvider({ disableHoverableContent, ...props }: TooltipProviderProps$1): react_jsx_runtime.JSX.Element;
+declare namespace TooltipProvider {
+    var displayName: string;
+}
+
+type AxiomProviderProps = {
+    children?: ReactNode;
+    /**
+     * Props for the `ToastProvider` component
+     *
+     * {@link https://optimizely-axiom.github.io/optiaxiom/components/toast/ Documentation}
+     */
+    toast?: Omit<ToastProviderProps, "children">;
+    /**
+     * Props for the `TooltipProvider` component
+     *
+     * {@link https://optimizely-axiom.github.io/optiaxiom/components/tooltip/ Documentation}
+     */
+    tooltip?: Omit<TooltipProviderProps, "children">;
+};
+interface ToastProviderProps extends ComponentPropsWithoutRef<typeof ToastProvider> {
+}
+interface TooltipProviderProps extends ComponentPropsWithoutRef<typeof TooltipProvider> {
+}
+declare function AxiomProvider({ children, toast, tooltip, }: AxiomProviderProps): react_jsx_runtime.JSX.Element;
+declare namespace AxiomProvider {
+    var displayName: string;
+}
+
+declare const Badge: react.ForwardRefExoticComponent<{
+    intent?: "information" | "success" | "warning" | "danger" | "neutral" | "primary" | undefined;
+    variant?: "strong" | "subtle" | undefined;
+} & Omit<{
+    lineClamp?: "2" | "4" | "1" | "3" | undefined;
+    truncate?: boolean | undefined;
+}, never> & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLSpanElement>>;
+
+declare const Banner: react.ForwardRefExoticComponent<{
+    intent?: "information" | "success" | "warning" | "danger" | "neutral" | undefined;
+} & {
+    /**
+     * Show a close button inside the banner and invoke this callback when the close button is clicked.
+     */
+    onDismiss?: () => void;
+} & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLDivElement>>;
+declare const Button: react.ForwardRefExoticComponent<Omit<{
+    /**
+     * Display content inside the button after `children`.
+     */
+    addonAfter?: ReactNode;
+    /**
+     * Display content inside the button before `children`.
+     */
+    addonBefore?: ReactNode;
+    /**
+     * Display an icon before or after the button content or omit `children` to only show the icon.
+     */
+    icon?: ReactNode;
+    /**
+     * Control whether to show the icon before or after the button content.
+     */
+    iconPosition?: "end" | "start";
+}, never> & Omit<NonNullable<Omit<{
+    intent?: "danger" | "neutral" | "primary" | undefined;
+    size?: "sm" | "md" | "lg" | undefined;
+    square?: boolean | undefined;
+    variant?: "strong" | "outline" | "subtle" | undefined;
+}, "intent" | "variant"> & {
+    appearance?: "default" | "danger" | "primary" | "subtle" | "inverse" | "danger-outline";
+    disabled?: boolean;
+    loading?: boolean;
+}>, never> & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, "size"> & Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">, "color" | "disabled" | "className"> & react.RefAttributes<HTMLButtonElement>>;
+
+declare const ButtonGroup: react.ForwardRefExoticComponent<{
+    /**
+     * The orientation/layout of the buttons inside the group.
+     */
+    orientation?: "horizontal" | "vertical";
+} & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLDivElement>>;
+
+declare const Code: react.ForwardRefExoticComponent<Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLElement>, HTMLElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLElement>>;
+
+type DialogProps = {
+    children?: React.ReactNode;
+    /**
+     * The initial open state in uncontrolled mode.
+     */
+    defaultOpen?: boolean;
+    /**
+     * Handler that is called when the open state changes.
+     */
+    onOpenChange?: (open: boolean) => void;
+    /**
+     * The open state in controlled mode.
+     */
+    open?: boolean;
+};
+declare function Dialog({ children, defaultOpen, onOpenChange, open: openProp, ...props }: DialogProps): react_jsx_runtime.JSX.Element;
+declare namespace Dialog {
+    var displayName: string;
+}
+
+declare const DialogBody: react.ForwardRefExoticComponent<Omit<Omit<Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLDivElement> | null | undefined;
+}, "ref"> & react.RefAttributes<HTMLDivElement>>;
+
+declare const DialogClose: react.ForwardRefExoticComponent<Omit<{
+    addonAfter?: react.ReactNode;
+    addonBefore?: react.ReactNode;
+    icon?: react.ReactNode;
+    iconPosition?: "end" | "start";
+}, never> & Omit<NonNullable<Omit<{
+    intent?: "danger" | "neutral" | "primary" | undefined;
+    size?: "sm" | "md" | "lg" | undefined;
+    square?: boolean | undefined;
+    variant?: "strong" | "outline" | "subtle" | undefined;
+}, "intent" | "variant"> & {
+    appearance?: "default" | "danger" | "primary" | "subtle" | "inverse" | "danger-outline";
+    disabled?: boolean;
+    loading?: boolean;
+}>, never> & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, "size"> & Omit<Omit<DialogCloseProps$1 & react.RefAttributes<HTMLButtonElement>, "ref">, "asChild" | "color" | "disabled" | "className"> & react.RefAttributes<HTMLButtonElement>>;
+
+declare const DialogFooter: react.ForwardRefExoticComponent<Omit<Omit<Omit<Omit<Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLDivElement> | null | undefined;
+}, "ref"> & react.RefAttributes<HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLDivElement> | null | undefined;
+}, "ref"> & react.RefAttributes<HTMLDivElement>>;
+
+declare const DialogForm: react.ForwardRefExoticComponent<Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.FormHTMLAttributes<HTMLFormElement>, HTMLFormElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLFormElement>>;
+
+declare const DialogHeader: react.ForwardRefExoticComponent<{
+    addonAfter?: ReactNode;
+    description?: ReactNode;
+} & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLHeadingElement>>;
+
+declare const DialogTrigger: react.ForwardRefExoticComponent<Omit<{
+    addonAfter?: react.ReactNode;
+    addonBefore?: react.ReactNode;
+    icon?: react.ReactNode;
+    iconPosition?: "end" | "start";
+}, never> & Omit<NonNullable<Omit<{
+    intent?: "danger" | "neutral" | "primary" | undefined;
+    size?: "sm" | "md" | "lg" | undefined;
+    square?: boolean | undefined;
+    variant?: "strong" | "outline" | "subtle" | undefined;
+}, "intent" | "variant"> & {
+    appearance?: "default" | "danger" | "primary" | "subtle" | "inverse" | "danger-outline";
+    disabled?: boolean;
+    loading?: boolean;
+}>, never> & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, "size"> & Omit<Omit<DialogTriggerProps$1 & react.RefAttributes<HTMLButtonElement>, "ref">, "asChild" | "color" | "disabled" | "className"> & react.RefAttributes<HTMLButtonElement>>;
+
+declare const Disclosure: react.ForwardRefExoticComponent<{
+    /**
+     * The initial open state in uncontrolled mode.
+     */
+    defaultOpen?: boolean;
+    /**
+     * Handler that is called when the open state changes.
+     */
+    onOpenChange?: (open: boolean) => void;
+    /**
+     * The open state in controlled mode.
+     */
+    open?: boolean;
+} & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<CollapsibleProps & react.RefAttributes<HTMLDivElement>, "ref">, "asChild" | "color" | "className" | "open" | "defaultOpen" | "onOpenChange"> & react.RefAttributes<HTMLDivElement>>;
+
+type DisclosureContentProps = ExcludeProps<BoxProps<typeof Content$2, {
+    transitionType?: ComponentPropsWithoutRef<typeof Transition>["type"];
+}>, "forceMount">;
+declare const DisclosureContent: react.ForwardRefExoticComponent<DisclosureContentProps & react.RefAttributes<HTMLDivElement>>;
+
+declare const DisclosureTrigger: react.ForwardRefExoticComponent<Pick<Omit<{
+    overlay?: boolean | undefined;
+} & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLDivElement>, "ref">, "overlay"> & {
+    addonAfter?: ReactNode;
+    addonBefore?: ReactNode;
+    chevronPosition?: "end" | "start";
+} & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLDivElement>>;
+
+type DrawerProps = ComponentPropsWithoutRef<typeof Root$4>;
+declare function Drawer({ children, defaultOpen, modal, onOpenChange, open: openProp, }: DrawerProps): react_jsx_runtime.JSX.Element;
+declare namespace Drawer {
+    var displayName: string;
+}
+
+declare const DrawerActions: react.ForwardRefExoticComponent<Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLHeadingElement>>;
+
+declare const DrawerBody: react.ForwardRefExoticComponent<Omit<Omit<Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLDivElement> | null | undefined;
+}, "ref"> & react.RefAttributes<HTMLDivElement>>;
+
+declare const DrawerClose: react.ForwardRefExoticComponent<Omit<{
+    addonAfter?: react.ReactNode;
+    addonBefore?: react.ReactNode;
+    icon?: react.ReactNode;
+    iconPosition?: "end" | "start";
+}, never> & Omit<NonNullable<Omit<{
+    intent?: "danger" | "neutral" | "primary" | undefined;
+    size?: "sm" | "md" | "lg" | undefined;
+    square?: boolean | undefined;
+    variant?: "strong" | "outline" | "subtle" | undefined;
+}, "intent" | "variant"> & {
+    appearance?: "default" | "danger" | "primary" | "subtle" | "inverse" | "danger-outline";
+    disabled?: boolean;
+    loading?: boolean;
+}>, never> & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, "size"> & Omit<Omit<DialogCloseProps$1 & react.RefAttributes<HTMLButtonElement>, "ref">, "asChild" | "color" | "disabled" | "className"> & react.RefAttributes<HTMLButtonElement>>;
+
+declare const DrawerContent: react.ForwardRefExoticComponent<{
+    position?: "left" | "right" | "bottom" | undefined;
+} & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<DialogContentProps$1 & react.RefAttributes<HTMLDivElement>, "ref">, "asChild" | "color" | "className"> & react.RefAttributes<HTMLDivElement>>;
+
+declare const DrawerDescription: react.ForwardRefExoticComponent<Omit<{
+    lineClamp?: "2" | "4" | "1" | "3" | undefined;
+    truncate?: boolean | undefined;
+}, never> & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<DialogDescriptionProps$1 & react.RefAttributes<HTMLParagraphElement>, "ref">, "asChild" | "color" | "className"> & react.RefAttributes<HTMLParagraphElement>>;
+
+declare const DrawerFooter: react.ForwardRefExoticComponent<Omit<Omit<Omit<Omit<Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLDivElement> | null | undefined;
+}, "ref"> & react.RefAttributes<HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLDivElement> | null | undefined;
+}, "ref"> & react.RefAttributes<HTMLDivElement>>;
+
+declare const DrawerHeader: react.ForwardRefExoticComponent<Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLDivElement>>;
+
+declare const DrawerTitle: react.ForwardRefExoticComponent<Omit<{
+    level?: "2" | "4" | "1" | "3";
+}, never> & Omit<{
+    lineClamp?: "2" | "4" | "1" | "3" | undefined;
+    truncate?: boolean | undefined;
+}, never> & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<DialogTitleProps & react.RefAttributes<HTMLHeadingElement>, "ref">, "asChild" | "color" | "className"> & react.RefAttributes<HTMLDivElement>>;
+
+declare const DrawerTrigger: react.ForwardRefExoticComponent<Omit<{
+    addonAfter?: react.ReactNode;
+    addonBefore?: react.ReactNode;
+    icon?: react.ReactNode;
+    iconPosition?: "end" | "start";
+}, never> & Omit<NonNullable<Omit<{
+    intent?: "danger" | "neutral" | "primary" | undefined;
+    size?: "sm" | "md" | "lg" | undefined;
+    square?: boolean | undefined;
+    variant?: "strong" | "outline" | "subtle" | undefined;
+}, "intent" | "variant"> & {
+    appearance?: "default" | "danger" | "primary" | "subtle" | "inverse" | "danger-outline";
+    disabled?: boolean;
+    loading?: boolean;
+}>, never> & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, "size"> & Omit<Omit<DialogTriggerProps$1 & react.RefAttributes<HTMLButtonElement>, "ref">, "asChild" | "color" | "disabled" | "className"> & react.RefAttributes<HTMLButtonElement>>;
+
+type MenuProps = {
+    children?: React.ReactNode;
+    /**
+     * The initial open state in uncontrolled mode.
+     */
+    defaultOpen?: boolean;
+    /**
+     * When enabled interaction with outside elements will be disabled and only dropdown content will be visible to screen readers.
+     */
+    modal?: boolean;
+    /**
+     * Handler that is called when the open state changes.
+     */
+    onOpenChange?: (open: boolean) => void;
+    /**
+     * The open state in controlled mode.
+     */
+    open?: boolean;
+};
+declare function DropdownMenu({ children, defaultOpen, onOpenChange, open: openProp, ...props }: MenuProps): react_jsx_runtime.JSX.Element;
+declare namespace DropdownMenu {
+    var displayName: string;
+}
+
+declare const DropdownMenuCheckboxItem: react.ForwardRefExoticComponent<Omit<NonNullable<{
+    intent?: "danger" | "neutral" | undefined;
+} & {
+    addonAfter?: react.ReactNode;
+    addonBefore?: react.ReactNode;
+    description?: react.ReactNode;
+    icon?: react.ReactNode;
+}>, never> & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<DropdownMenuCheckboxItemProps & react.RefAttributes<HTMLDivElement>, "ref">, "asChild" | "color" | "className"> & react.RefAttributes<HTMLDivElement>>;
+
+type DropdownMenuContentProps = ExcludeProps<BoxProps<typeof Content, Pick<ComponentPropsWithoutRef<typeof MenuListbox>, "maxH" | "minW"> & {
+    /**
+     * Whether to show loading spinner inside the menu.
+     */
+    loading?: boolean;
+}>, "alignOffset" | "arrowPadding" | "avoidCollisions" | "collisionBoundary" | "collisionPadding" | "forceMount" | "hideWhenDetached" | "loop" | "sideOffset" | "sticky" | "updatePositionStrategy">;
+declare const DropdownMenuContent: react.ForwardRefExoticComponent<DropdownMenuContentProps & react.RefAttributes<HTMLDivElement>>;
+
+declare const DropdownMenuGroup: react.ForwardRefExoticComponent<Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<DropdownMenuGroupProps & react.RefAttributes<HTMLDivElement>, "ref">, "asChild" | "color" | "className"> & react.RefAttributes<HTMLDivElement>>;
+
+declare const DropdownMenuItem: react.ForwardRefExoticComponent<Omit<NonNullable<{
+    intent?: "danger" | "neutral" | undefined;
+} & {
+    addonAfter?: react.ReactNode;
+    addonBefore?: react.ReactNode;
+    description?: react.ReactNode;
+    icon?: react.ReactNode;
+}>, never> & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<DropdownMenuItemProps & react.RefAttributes<HTMLDivElement>, "ref">, "asChild" | "color" | "className"> & react.RefAttributes<HTMLDivElement>>;
+
+declare const DropdownMenuLabel: react.ForwardRefExoticComponent<Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<DropdownMenuLabelProps & react.RefAttributes<HTMLDivElement>, "ref">, "asChild" | "color" | "className"> & react.RefAttributes<HTMLDivElement>>;
+
+declare const DropdownMenuSeparator: react.ForwardRefExoticComponent<Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<DropdownMenuSeparatorProps & react.RefAttributes<HTMLDivElement>, "ref">, "asChild" | "color" | "className"> & react.RefAttributes<HTMLDivElement>>;
+
+type MenuSubProps = {
+    children?: React.ReactNode;
+    /**
+     * The initial open state in uncontrolled mode.
+     */
+    defaultOpen?: boolean;
+    /**
+     * Handler that is called when the open state changes.
+     */
+    onOpenChange?: (open: boolean) => void;
+    /**
+     * The open state in controlled mode.
+     */
+    open?: boolean;
+};
+declare function DropdownMenuSub({ children, defaultOpen, onOpenChange, open: openProp, ...props }: MenuSubProps): react_jsx_runtime.JSX.Element;
+declare namespace DropdownMenuSub {
+    var displayName: string;
+}
+
+type MenuSubContentProps = ExcludeProps<BoxProps<typeof SubContent, Pick<ComponentPropsWithoutRef<typeof MenuListbox>, "maxH" | "minW">>, "alignOffset" | "arrowPadding" | "avoidCollisions" | "collisionBoundary" | "collisionPadding" | "forceMount" | "hideWhenDetached" | "loop" | "sideOffset" | "sticky" | "updatePositionStrategy">;
+declare const DropdownMenuSubContent: react.ForwardRefExoticComponent<MenuSubContentProps & react.RefAttributes<HTMLDivElement>>;
+
+declare const DropdownMenuTrigger: react.ForwardRefExoticComponent<Omit<Omit<{
+    addonAfter?: react.ReactNode;
+    addonBefore?: react.ReactNode;
+    icon?: react.ReactNode;
+    iconPosition?: "end" | "start";
+}, never> & Omit<NonNullable<Omit<{
+    intent?: "danger" | "neutral" | "primary" | undefined;
+    size?: "sm" | "md" | "lg" | undefined;
+    square?: boolean | undefined;
+    variant?: "strong" | "outline" | "subtle" | undefined;
+}, "intent" | "variant"> & {
+    appearance?: "default" | "danger" | "primary" | "subtle" | "inverse" | "danger-outline";
+    disabled?: boolean;
+    loading?: boolean;
+}>, never> & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, "size"> & Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">, "color" | "disabled" | "className"> & react.RefAttributes<HTMLButtonElement>, "ref"> & react.RefAttributes<HTMLButtonElement>>;
+
+declare const EllipsisMenuButton: react.ForwardRefExoticComponent<Omit<Omit<{
+    addonAfter?: react.ReactNode;
+    addonBefore?: react.ReactNode;
+    icon?: react.ReactNode;
+    iconPosition?: "end" | "start";
+}, never> & Omit<NonNullable<Omit<{
+    intent?: "danger" | "neutral" | "primary" | undefined;
+    size?: "sm" | "md" | "lg" | undefined;
+    square?: boolean | undefined;
+    variant?: "strong" | "outline" | "subtle" | undefined;
+}, "intent" | "variant"> & {
+    appearance?: "default" | "danger" | "primary" | "subtle" | "inverse" | "danger-outline";
+    disabled?: boolean;
+    loading?: boolean;
+}>, never> & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, "size"> & Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">, "color" | "disabled" | "className"> & react.RefAttributes<HTMLButtonElement>, "ref"> & react.RefAttributes<HTMLButtonElement>>;
+
+declare const Field: react.ForwardRefExoticComponent<{
+    /**
+     * Provide description and help text for the field.
+     */
+    description?: ReactNode;
+    /**
+     * Display validation or other errors for the input.
+     */
+    error?: ReactNode;
+    /**
+     * Display a help icon with additional context for the input.
+     */
+    info?: ReactNode;
+    /**
+     * Override the default generated input ID used for associating the label to the input.
+     */
+    inputId?: string;
+    /**
+     * The label of the field.
+     */
+    label?: ReactNode;
+    /**
+     * Override the default generated label ID used for associating the controls to the label.
+     */
+    labelId?: string;
+    /**
+     * Display an asterisk for required inputs.
+     */
+    required?: boolean;
+} & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLDivElement>>;
+
+declare const FieldLabel: react.ForwardRefExoticComponent<{
+    info?: ReactNode;
+    inputId?: string;
+    labelId?: string;
+    required?: boolean;
+} & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLDivElement>>;
+
+declare const Flex: react.ForwardRefExoticComponent<Omit<Omit<Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLDivElement> | null | undefined;
+}, "ref"> & react.RefAttributes<HTMLDivElement>>;
+
+declare const Grid: react.ForwardRefExoticComponent<Omit<Omit<Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLDivElement> | null | undefined;
+}, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const Text: react.ForwardRefExoticComponent<Omit<{
+    lineClamp?: "2" | "4" | "1" | "3" | undefined;
+    truncate?: boolean | undefined;
+}, never> & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLParagraphElement>>;
+declare const mapLevelToTag: {
+    readonly "1": "h1";
+    readonly "2": "h2";
+    readonly "3": "h3";
+    readonly "4": "h4";
+};
+declare const Heading: react.ForwardRefExoticComponent<Omit<{
+    /**
+     * Switch between the different h1-h6 levels.
+     */
+    level?: keyof typeof mapLevelToTag;
+}, never> & Omit<{
+    lineClamp?: "2" | "4" | "1" | "3" | undefined;
+    truncate?: boolean | undefined;
+}, never> & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLHeadingElement>>;
+
+declare const Indicator: react.ForwardRefExoticComponent<{
+    /**
+     * Set the content of the badge.
+     */
+    content?: ReactNode;
+    /**
+     * Whether to show or hide badge.
+     */
+    disabled?: boolean;
+    /**
+     * Whether to offset the badge and display slightly outside the content box.
+     */
+    offset?: boolean;
+    /**
+     * Whether to show a ping animation for the badge.
+     */
+    ping?: boolean;
+    /**
+     * Set which corner the badge is displayed.
+     */
+    position?: "bottom-right" | "top-right";
+} & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<{
+    intent?: "information" | "success" | "warning" | "danger" | "neutral" | "primary" | undefined;
+    variant?: "strong" | "subtle" | undefined;
+} & Omit<{
+    lineClamp?: "2" | "4" | "1" | "3" | undefined;
+    truncate?: boolean | undefined;
+}, never> & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLSpanElement>, "ref">, "asChild" | "p" | "fontFamily" | "fontSize" | "size" | "animation" | "borderColor" | "color" | "cursor" | "empty" | "fontWeight" | "objectFit" | "overflowX" | "overflowY" | "pointerEvents" | "textAlign" | "textTransform" | "transition" | "whiteSpace" | "bg" | "border" | "borderB" | "borderL" | "borderR" | "borderT" | "m" | "mx" | "my" | "mb" | "ml" | "mr" | "mt" | "overflow" | "px" | "py" | "pb" | "pl" | "pr" | "pt" | "rounded" | "shadow" | "z" | "gap" | "alignItems" | "alignSelf" | "display" | "flex" | "flexDirection" | "flexWrap" | "gridColumn" | "gridTemplateColumns" | "justifyContent" | "justifyItems" | "placeItems" | "maxH" | "maxW" | "h" | "w" | "className" | "content"> & react.RefAttributes<HTMLDivElement>>;
+
+declare const Input: react.ForwardRefExoticComponent<Pick<Omit<Pick<{
+    addonPointerEvents?: "auto" | "none";
+    inputRef: react.RefObject<HTMLInputElement & HTMLTextAreaElement>;
+} & {
+    children: React.ReactNode;
+}, "addonPointerEvents"> & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLInputElement & HTMLTextAreaElement>, "ref">, "addonPointerEvents"> & {
+    appearance?: "number" | "default" | undefined;
+    size?: "md" | "lg" | "xl" | undefined;
+} & {
+    /**
+     * Display content inside the input at the end.
+     */
+    addonAfter?: ReactNode;
+    /**
+     * Display content inside the input at the start.
+     */
+    addonBefore?: ReactNode;
+    /**
+     * Control the native input `size` attribute.
+     */
+    htmlSize?: number;
+} & Omit<NonNullable<{
+    size?: "md" | "lg" | "xl" | undefined;
+} & {
+    disabled?: boolean;
+    error?: boolean;
+}>, "size"> & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, "size"> & Omit<Omit<react.DetailedHTMLProps<react.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref">, "size" | "color" | "disabled" | "className"> & react.RefAttributes<HTMLInputElement>>;
+
+declare const InputAddon: react.ForwardRefExoticComponent<Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLDivElement>>;
+declare const InputControl: react.ForwardRefExoticComponent<Omit<NonNullable<{
+    size?: "md" | "lg" | "xl" | undefined;
+} & {
+    /**
+     * Whether the input is disabled.
+     */
+    disabled?: boolean;
+    /**
+     * Whether to show the input error state.
+     */
+    error?: boolean;
+}>, never> & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, "size"> & Omit<NonNullable<Omit<react.DetailedHTMLProps<react.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref"> | Omit<react.DetailedHTMLProps<react.TextareaHTMLAttributes<HTMLTextAreaElement>, HTMLTextAreaElement>, "ref">>, "color" | "disabled" | "className"> & react.RefAttributes<HTMLInputElement & HTMLTextAreaElement>>;
+
+declare const InputRoot: react.ForwardRefExoticComponent<Pick<{
+    addonPointerEvents?: "auto" | "none";
+    inputRef: react.RefObject<HTMLInputElement & HTMLTextAreaElement>;
+} & {
+    children: React.ReactNode;
+}, "addonPointerEvents"> & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLInputElement & HTMLTextAreaElement>>;
+
+declare const mapKeyToCode: {
+    command: string;
+    ctrl: string;
+    down: string;
+    enter: string;
+    escape: string;
+    help: string;
+    left: string;
+    option: string;
+    right: string;
+    shift: string;
+    space: string;
+    tab: string;
+    up: string;
+};
+declare const Kbd: react.ForwardRefExoticComponent<{
+    variant?: "outline" | "subtle" | undefined;
+} & {
+    keys?: Array<keyof typeof mapKeyToCode> | keyof typeof mapKeyToCode;
+} & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLElement>, HTMLElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLElement>>;
+
+declare const Listbox: react.ForwardRefExoticComponent<Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLDivElement>>;
+
+declare const ListboxCheckboxItem: react.ForwardRefExoticComponent<Omit<Omit<NonNullable<{
+    intent?: "danger" | "neutral" | undefined;
+} & {
+    addonAfter?: react.ReactNode;
+    addonBefore?: react.ReactNode;
+    description?: react.ReactNode;
+    icon?: react.ReactNode;
+}>, never> & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+
+declare const ListboxEmpty: react.ForwardRefExoticComponent<Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLDivElement>>;
+
+declare const ListboxFooter: react.ForwardRefExoticComponent<Omit<Omit<Omit<Omit<Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLDivElement> | null | undefined;
+}, "ref"> & react.RefAttributes<HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void | react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof react.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | react.RefObject<HTMLDivElement> | null | undefined;
+}, "ref"> & react.RefAttributes<HTMLDivElement>>;
+
+declare const ListboxGroup: react.ForwardRefExoticComponent<Omit<Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const ListboxItem: react.ForwardRefExoticComponent<Omit<NonNullable<{
+    intent?: "danger" | "neutral" | undefined;
+} & {
+    /**
+     * Display content inside the item after `children`.
+     */
+    addonAfter?: ReactNode;
+    /**
+     * Display content inside the item before `children`.
+     */
+    addonBefore?: ReactNode;
+    /**
+     * Add secondary text after the primary label.
+     */
+    description?: ReactNode;
+    /**
+     * Display an icon before the item content.
+     */
+    icon?: ReactNode;
+}>, never> & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLDivElement>>;
+
+declare const ListboxItemIndicator: react.ForwardRefExoticComponent<{
+    active?: boolean;
+} & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<Omit<react.SVGProps<SVGSVGElement>, "ref"> & react.RefAttributes<SVGSVGElement>, "ref">, "fontFamily" | "fontSize" | "color" | "cursor" | "fontWeight" | "pointerEvents" | "overflow" | "z" | "display" | "className"> & react.RefAttributes<SVGSVGElement>>;
+
+declare const ListboxLabel: react.ForwardRefExoticComponent<Omit<Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+
+declare const ListboxRadioItem: react.ForwardRefExoticComponent<Omit<Omit<NonNullable<{
+    intent?: "danger" | "neutral" | undefined;
+} & {
+    addonAfter?: react.ReactNode;
+    addonBefore?: react.ReactNode;
+    description?: react.ReactNode;
+    icon?: react.ReactNode;
+}>, never> & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+
+declare const ListboxScrollArea: react.ForwardRefExoticComponent<Omit<Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+
+declare const ListboxSeparator: react.ForwardRefExoticComponent<Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<{
+    orientation?: ("vertical" | "horizontal" | {
+        readonly base?: "vertical" | "horizontal" | undefined;
+        readonly sm?: "vertical" | "horizontal" | undefined;
+        readonly md?: "vertical" | "horizontal" | undefined;
+    } | undefined) | ResponsiveArray<2 | 1 | 3, "vertical" | "horizontal" | null>;
+} & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<SeparatorProps & react.RefAttributes<HTMLDivElement>, "ref">, "asChild" | "color" | "className" | "orientation"> & react.RefAttributes<HTMLDivElement>, "ref">, "asChild" | "p" | "fontFamily" | "fontSize" | "size" | "animation" | "borderColor" | "color" | "cursor" | "empty" | "fontWeight" | "objectFit" | "overflowX" | "overflowY" | "pointerEvents" | "textAlign" | "textTransform" | "transition" | "whiteSpace" | "bg" | "border" | "borderB" | "borderL" | "borderR" | "borderT" | "m" | "mx" | "my" | "mb" | "ml" | "mr" | "mt" | "overflow" | "px" | "py" | "pb" | "pl" | "pr" | "pt" | "rounded" | "shadow" | "z" | "gap" | "alignItems" | "alignSelf" | "display" | "flex" | "flexDirection" | "flexWrap" | "gridColumn" | "gridTemplateColumns" | "justifyContent" | "justifyItems" | "placeItems" | "maxH" | "maxW" | "h" | "w" | "className"> & react.RefAttributes<HTMLDivElement>>;
+
+declare const ModalLayer: react.ForwardRefExoticComponent<Pick<Omit<Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLDivElement>, "ref">, "asChild"> & {
+    children?: ReactNode;
+} & react.RefAttributes<HTMLDivElement>>;
+
+declare const Nav: react.ForwardRefExoticComponent<{
+    defaultExpanded?: boolean;
+    expanded?: boolean;
+    onExpandedChange?: (expanded: boolean) => void;
+} & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLElement>, HTMLElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLDivElement>>;
+declare const NavAccountItem: react.ForwardRefExoticComponent<{
+    name?: string;
+    organization?: string;
+    src?: string;
+} & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLButtonElement>>;
+
+declare const NavBody: react.ForwardRefExoticComponent<Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLDivElement>>;
+
+declare const NavFooter: react.ForwardRefExoticComponent<Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLDivElement>>;
+
+declare const NavHeader: react.ForwardRefExoticComponent<Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLDivElement>>;
+declare const NavItem: react.ForwardRefExoticComponent<{
+    active?: boolean;
+    /**
+     * Display content inside the button after `children`.
+     */
+    addonAfter?: ReactNode;
+    /**
+     * Display an icon before button content.
+     */
+    icon?: ReactNode;
+} & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLButtonElement>>;
+
+declare const NavList: react.ForwardRefExoticComponent<Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLUListElement>>;
+declare const Pagination: react.ForwardRefExoticComponent<{
+    /**
+     * The default active page in uncontrolled mode.
+     */
+    defaultPage?: number;
+    /**
+     * Whether to disable all button.
+     */
+    disabled?: boolean;
+    /**
+     * Handler that is called when the active page is changed.
+     */
+    onPageChange?: (offset: number) => void;
+    /**
+     * The active page in controlled mode.
+     */
+    page?: number;
+    /**
+     * The total number of pages to display.
+     */
+    total: number;
+} & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLElement>, HTMLElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLElement>>;
+
+declare const Paper: react.ForwardRefExoticComponent<{
+    elevation?: "dialog" | "menu" | "drawer" | undefined;
+} & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLDivElement>>;
+
+type PopoverProps = {
+    children?: React.ReactNode;
+    /**
+     * The initial open state in uncontrolled mode.
+     */
+    defaultOpen?: boolean;
+    /**
+     * When enabled interaction with outside elements will be disabled and only popover content will be visible to screen readers.
+     */
+    modal?: boolean;
+    /**
+     * Handler that is called when the open state changes.
+     */
+    onOpenChange?: (open: boolean) => void;
+    /**
+     * The open state in controlled mode.
+     */
+    open?: boolean;
+};
+declare function Popover({ children, defaultOpen, onOpenChange, open: openProp, ...props }: PopoverProps): react_jsx_runtime.JSX.Element;
+declare namespace Popover {
+    var displayName: string;
+}
+
+declare const PopoverAnchor: react.ForwardRefExoticComponent<Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<PopoverAnchorProps & react.RefAttributes<HTMLDivElement>, "ref">, "asChild" | "color" | "className"> & react.RefAttributes<HTMLDivElement>>;
+
+declare const PopoverTrigger: react.ForwardRefExoticComponent<Omit<{
+    addonAfter?: react.ReactNode;
+    addonBefore?: react.ReactNode;
+    icon?: react.ReactNode;
+    iconPosition?: "end" | "start";
+}, never> & Omit<NonNullable<Omit<{
+    intent?: "danger" | "neutral" | "primary" | undefined;
+    size?: "sm" | "md" | "lg" | undefined;
+    square?: boolean | undefined;
+    variant?: "strong" | "outline" | "subtle" | undefined;
+}, "intent" | "variant"> & {
+    appearance?: "default" | "danger" | "primary" | "subtle" | "inverse" | "danger-outline";
+    disabled?: boolean;
+    loading?: boolean;
+}>, never> & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, "size"> & Omit<Omit<PopoverTriggerProps & react.RefAttributes<HTMLButtonElement>, "ref">, "asChild" | "color" | "disabled" | "className"> & react.RefAttributes<HTMLButtonElement>>;
+
+declare const Progress: react.ForwardRefExoticComponent<Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<ProgressProps & react.RefAttributes<HTMLDivElement>, "ref">, "asChild" | "color" | "className"> & {
+    intent?: "success" | "danger" | "primary" | undefined;
+} & react.RefAttributes<HTMLDivElement>>;
+
+declare const Radio: react.ForwardRefExoticComponent<{
+    /**
+     * Add helper text after the label.
+     */
+    description?: ReactNode;
+} & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<{
+    onCheckedChange?: (checked: boolean) => void;
+} & Omit<Omit<react.DetailedHTMLProps<react.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref">, never> & react.RefAttributes<HTMLInputElement>, "ref">, "size" | "color" | "className"> & react.RefAttributes<HTMLInputElement>>;
+
+type InputProps = ComponentPropsWithoutRef<"input">;
+declare const RadioGroup: react.ForwardRefExoticComponent<{
+    defaultValue?: string;
+    disabled?: InputProps["disabled"];
+    name?: InputProps["name"];
+    onBlur?: InputProps["onBlur"];
+    onChange?: InputProps["onChange"];
+    onValueChange?: (value: string) => void;
+    value?: string;
+} & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "color" | "className" | "defaultValue" | "onBlur" | "onChange"> & react.RefAttributes<HTMLDivElement>>;
+
+type SearchProps = ComponentPropsWithRef<typeof Input> & {
+    onValueClear?: () => void;
+};
+declare const SearchInput: react.ForwardRefExoticComponent<Omit<SearchProps, "ref"> & react.RefAttributes<HTMLInputElement>>;
+
+declare const SegmentedControl: react.ForwardRefExoticComponent<{
+    type?: "multiple" | "single";
+} & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<NonNullable<Omit<ToggleGroupSingleProps & react.RefAttributes<HTMLDivElement>, "ref"> | Omit<ToggleGroupMultipleProps & react.RefAttributes<HTMLDivElement>, "ref">>, "asChild" | "color" | "className" | "type"> & react.RefAttributes<HTMLDivElement>>;
+
+declare const SegmentedControlItem: react.ForwardRefExoticComponent<Omit<{
+    addonAfter?: react.ReactNode;
+    addonBefore?: react.ReactNode;
+    icon?: react.ReactNode;
+    iconPosition?: "end" | "start";
+}, never> & Omit<NonNullable<Omit<{
+    intent?: "danger" | "neutral" | "primary" | undefined;
+    size?: "sm" | "md" | "lg" | undefined;
+    square?: boolean | undefined;
+    variant?: "strong" | "outline" | "subtle" | undefined;
+}, "intent" | "variant"> & {
+    appearance?: "default" | "danger" | "primary" | "subtle" | "inverse" | "danger-outline";
+    disabled?: boolean;
+    loading?: boolean;
+}>, never> & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, "size"> & Omit<Omit<ToggleGroupItemProps & react.RefAttributes<HTMLButtonElement>, "ref">, "asChild" | "color" | "disabled" | "className"> & react.RefAttributes<HTMLButtonElement>>;
+
+declare const Separator: react.ForwardRefExoticComponent<{
+    orientation?: ("vertical" | "horizontal" | {
+        readonly base?: "vertical" | "horizontal" | undefined;
+        readonly sm?: "vertical" | "horizontal" | undefined;
+        readonly md?: "vertical" | "horizontal" | undefined;
+    } | undefined) | ResponsiveArray<2 | 1 | 3, "vertical" | "horizontal" | null>;
+} & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<SeparatorProps & react.RefAttributes<HTMLDivElement>, "ref">, "asChild" | "color" | "className" | "orientation"> & react.RefAttributes<HTMLDivElement>>;
+
+declare const Sidebar: react.ForwardRefExoticComponent<{
+    /**
+     * The initial expanded state in uncontrolled mode.
+     */
+    defaultExpanded?: boolean;
+    /**
+     * The expanded state in controlled mode.
+     */
+    expanded?: boolean;
+    /**
+     * Handler that is called when the expanded state changes.
+     */
+    onExpandedChange?: (expanded: boolean) => void;
+} & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLDivElement>>;
+
+type SidebarToggleProps = Omit<ComponentPropsWithRef<typeof NavItem>, "aria-label"> & {
+    "aria-label"?: string;
+};
+declare const SidebarToggle: react.ForwardRefExoticComponent<Omit<SidebarToggleProps, "ref"> & react.RefAttributes<HTMLButtonElement>>;
+
+declare const Skeleton: react.ForwardRefExoticComponent<{
+    children?: ReactElement;
+    /**
+     * Render skeleton as a circle if `true`.
+     */
+    circle?: boolean;
+} & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref">, "children" | "color" | "className"> & react.RefAttributes<HTMLSpanElement>>;
+
+declare const Spinner: react.ForwardRefExoticComponent<{
+    appearance?: "default" | "inverse";
+} & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLDivElement>>;
+
+declare const Switch: react.ForwardRefExoticComponent<{
+    size?: "md" | "lg" | undefined;
+} & {
+    /**
+     * Add helper text after the label.
+     */
+    description?: ReactNode;
+} & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, "size"> & Omit<Omit<{
+    onCheckedChange?: (checked: boolean) => void;
+} & Omit<Omit<react.DetailedHTMLProps<react.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref">, never> & react.RefAttributes<HTMLInputElement>, "ref">, "size" | "color" | "className"> & react.RefAttributes<HTMLInputElement>>;
+
+declare const Tabs: react.ForwardRefExoticComponent<Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<TabsProps & react.RefAttributes<HTMLDivElement>, "ref">, "asChild" | "color" | "className"> & react.RefAttributes<HTMLDivElement>>;
+
+type TabsContentProps = ExcludeProps<BoxProps<typeof TabsContent$1>, "forceMount">;
+declare const TabsContent: react.ForwardRefExoticComponent<TabsContentProps & react.RefAttributes<HTMLDivElement>>;
+
+declare const TabsList: react.ForwardRefExoticComponent<Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<TabsListProps & react.RefAttributes<HTMLDivElement>, "ref">, "asChild" | "color" | "className"> & react.RefAttributes<HTMLDivElement>>;
+
+declare const TabsTrigger: react.ForwardRefExoticComponent<{
+    /**
+     * Display content inside the button after `children`.
+     */
+    addonAfter?: ReactNode;
+    /**
+     * Display content inside the button before `children`.
+     */
+    addonBefore?: ReactNode;
+} & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<TabsTriggerProps & react.RefAttributes<HTMLButtonElement>, "ref">, "asChild" | "color" | "className"> & react.RefAttributes<HTMLButtonElement>>;
+
+declare const TextareaAutosize: react.ForwardRefExoticComponent<{
+    maxRows?: 2 | 1 | 3 | 4 | 5 | undefined;
+    resize?: "auto" | "none" | "vertical" | undefined;
+} & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.TextareaHTMLAttributes<HTMLTextAreaElement>, HTMLTextAreaElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLTextAreaElement>>;
+
+declare const Textarea: react.ForwardRefExoticComponent<Pick<Omit<Pick<{
+    addonPointerEvents?: "auto" | "none";
+    inputRef: react.RefObject<HTMLInputElement & HTMLTextAreaElement>;
+} & {
+    children: React.ReactNode;
+}, "addonPointerEvents"> & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLInputElement & HTMLTextAreaElement>, "ref">, "addonPointerEvents"> & {
+    addonAfter?: ReactNode;
+    addonBefore?: ReactNode;
+    children?: never;
+    /**
+     * Limits the height of the textarea when `resize=auto` is used.
+     */
+    maxRows?: ComponentPropsWithRef<typeof TextareaAutosize>["maxRows"];
+    resize?: ComponentPropsWithRef<typeof TextareaAutosize>["resize"];
+    size?: never;
+} & Omit<NonNullable<{
+    size?: "md" | "lg" | "xl" | undefined;
+} & {
+    disabled?: boolean;
+    error?: boolean;
+}>, "size"> & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, "size"> & Omit<Omit<{
+    maxRows?: 2 | 1 | 3 | 4 | 5 | undefined;
+    resize?: "auto" | "none" | "vertical" | undefined;
+} & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<react.DetailedHTMLProps<react.TextareaHTMLAttributes<HTMLTextAreaElement>, HTMLTextAreaElement>, "ref">, "color" | "className"> & react.RefAttributes<HTMLTextAreaElement>, "ref">, "asChild" | "children" | "p" | "fontFamily" | "fontSize" | "size" | "animation" | "borderColor" | "color" | "cursor" | "empty" | "fontWeight" | "objectFit" | "overflowX" | "overflowY" | "pointerEvents" | "textAlign" | "textTransform" | "transition" | "whiteSpace" | "bg" | "border" | "borderB" | "borderL" | "borderR" | "borderT" | "m" | "mx" | "my" | "mb" | "ml" | "mr" | "mt" | "overflow" | "px" | "py" | "pb" | "pl" | "pr" | "pt" | "rounded" | "shadow" | "z" | "disabled" | "gap" | "alignItems" | "alignSelf" | "display" | "flex" | "flexDirection" | "flexWrap" | "gridColumn" | "gridTemplateColumns" | "justifyContent" | "justifyItems" | "placeItems" | "maxH" | "maxW" | "h" | "w" | "className" | "resize" | "maxRows"> & react.RefAttributes<HTMLTextAreaElement>>;
+
+type ThemeProviderProps = {
+    children?: ReactNode;
+    selector?: string;
+};
+declare function ThemeProvider({ children, selector, }: ThemeProviderProps): react_jsx_runtime.JSX.Element;
+declare namespace ThemeProvider {
+    var displayName: string;
+}
+
+declare const root: (props?: {
+    intent?: "information" | "success" | "warning" | "danger" | "neutral" | undefined;
+} | undefined, className?: string) => {
+    className: string;
+};
+type RootVariants = RecipeVariants<typeof root>;
+
+type ToastProps = ExcludeProps<BoxProps<typeof Root$2, RootVariants>, "forceMount" | "open">;
+declare const Toast: react.ForwardRefExoticComponent<ToastProps & react.RefAttributes<HTMLLIElement>>;
+
+declare const ToastAction: react.ForwardRefExoticComponent<Omit<{
+    addonAfter?: react.ReactNode;
+    addonBefore?: react.ReactNode;
+    icon?: react.ReactNode;
+    iconPosition?: "end" | "start";
+}, never> & Omit<NonNullable<Omit<{
+    intent?: "danger" | "neutral" | "primary" | undefined;
+    size?: "sm" | "md" | "lg" | undefined;
+    square?: boolean | undefined;
+    variant?: "strong" | "outline" | "subtle" | undefined;
+}, "intent" | "variant"> & {
+    appearance?: "default" | "danger" | "primary" | "subtle" | "inverse" | "danger-outline";
+    disabled?: boolean;
+    loading?: boolean;
+}>, never> & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, "size"> & Omit<Omit<ToastActionProps & react.RefAttributes<HTMLButtonElement>, "ref">, "asChild" | "color" | "disabled" | "className"> & react.RefAttributes<HTMLButtonElement>>;
+
+declare const ToastTitle: react.ForwardRefExoticComponent<Omit<{
+    lineClamp?: "2" | "4" | "1" | "3" | undefined;
+    truncate?: boolean | undefined;
+}, never> & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, never> & Omit<Omit<ToastTitleProps & react.RefAttributes<HTMLDivElement>, "ref">, "asChild" | "color" | "className"> & react.RefAttributes<HTMLDivElement>>;
+
+declare const ToggleButton: react.ForwardRefExoticComponent<{
+    /**
+     * Control the appearance by selecting between the different button types.
+     */
+    appearance?: "default" | "subtle";
+} & Omit<{
+    addonAfter?: react.ReactNode;
+    addonBefore?: react.ReactNode;
+    icon?: react.ReactNode;
+    iconPosition?: "end" | "start";
+}, never> & Omit<NonNullable<Omit<{
+    intent?: "danger" | "neutral" | "primary" | undefined;
+    size?: "sm" | "md" | "lg" | undefined;
+    square?: boolean | undefined;
+    variant?: "strong" | "outline" | "subtle" | undefined;
+}, "intent" | "variant"> & {
+    appearance?: "default" | "danger" | "primary" | "subtle" | "inverse" | "danger-outline";
+    disabled?: boolean;
+    loading?: boolean;
+}>, "appearance"> & Omit<NonNullable<Sprinkles & {
+    asChild?: boolean;
+    className?: string;
+}>, "size"> & Omit<Omit<ToggleProps$1 & react.RefAttributes<HTMLButtonElement>, "ref">, "asChild" | "color" | "disabled" | "className"> & react.RefAttributes<HTMLButtonElement>>;
+
+type TooltipContentProps = ExcludeProps<BoxProps<typeof Content$3>, "alignOffset" | "arrowPadding" | "avoidCollisions" | "collisionBoundary" | "collisionPadding" | "forceMount" | "hideWhenDetached" | "sideOffset" | "sticky" | "updatePositionStrategy">;
+declare const TooltipContent: react.ForwardRefExoticComponent<TooltipContentProps & react.RefAttributes<HTMLDivElement>>;
+
+type TooltipRootProps = BoxProps<typeof Root$1, {
+    auto?: boolean;
+}>;
+declare function TooltipRoot({ auto, children, defaultOpen, delayDuration, onOpenChange, open: openProp, ...props }: TooltipRootProps): react_jsx_runtime.JSX.Element;
+declare namespace TooltipRoot {
+    var displayName: string;
+}
+
+type TooltipProps = ExcludeProps<BoxProps<typeof TooltipContent, Pick<ComponentPropsWithRef<typeof TooltipRoot>, "delayDuration"> & {
+    /**
+     * Enable this option to only show the tooltip when children is partially hidden due to text overflow.
+     */
+    auto?: boolean;
+    children: ReactNode;
+    /**
+     * The tooltip content.
+     */
+    content?: ReactNode;
+    /**
+     * The initial open state in uncontrolled mode.
+     */
+    defaultOpen?: boolean;
+    /**
+     * Whether to show or hide tooltip even if there's content.
+     */
+    disabled?: boolean;
+    /**
+     * Handler that is called when the open state changes.
+     */
+    onOpenChange?: (open: boolean) => void;
+    /**
+     * The open state in controlled mode.
+     */
+    open?: boolean;
+}>, "asChild">;
+declare function Tooltip({ auto, children, content, defaultOpen, delayDuration, disabled, onOpenChange, open, ...props }: TooltipProps): react_jsx_runtime.JSX.Element;
+declare namespace Tooltip {
+    var displayName: string;
+}
+
+declare const TooltipTrigger: react.ForwardRefExoticComponent<Omit<TooltipTriggerProps & react.RefAttributes<HTMLButtonElement>, "ref"> & react.RefAttributes<HTMLButtonElement>>;
+
+declare function TransitionGroup({ children, open, }: {
+    children?: false | ReactElement;
+    open?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare namespace TransitionGroup {
+    var displayName: string;
+}
+
+export { Heading as $, Alert as A, Badge as B, Code as C, Dialog as D, DrawerBody as E, DrawerClose as F, DrawerContent as G, DrawerDescription as H, DrawerFooter as I, DrawerHeader as J, DrawerTitle as K, DrawerTrigger as L, DropdownMenu as M, DropdownMenuCheckboxItem as N, DropdownMenuContent as O, DropdownMenuGroup as P, DropdownMenuItem as Q, DropdownMenuLabel as R, DropdownMenuSeparator as S, DropdownMenuSub as T, DropdownMenuSubContent as U, DropdownMenuTrigger as V, EllipsisMenuButton as W, Field as X, FieldLabel as Y, Flex as Z, Grid as _, AlertDialog as a, Indicator as a0, Input as a1, InputAddon as a2, InputControl as a3, InputRoot as a4, Kbd as a5, Listbox as a6, ListboxCheckboxItem as a7, ListboxEmpty as a8, ListboxFooter as a9, Separator as aA, Sidebar as aB, SidebarToggle as aC, Skeleton as aD, Spinner as aE, Switch as aF, Tabs as aG, TabsContent as aH, TabsList as aI, TabsTrigger as aJ, Text as aK, Textarea as aL, ThemeProvider as aM, Toast as aN, ToastAction as aO, ToastTitle as aP, ToggleButton as aQ, Tooltip as aR, TooltipContent as aS, TooltipRoot as aT, TooltipTrigger as aU, TransitionGroup as aV, ListboxGroup as aa, ListboxItem as ab, ListboxItemIndicator as ac, ListboxLabel as ad, ListboxRadioItem as ae, ListboxScrollArea as af, ListboxSeparator as ag, ModalLayer as ah, Nav as ai, NavAccountItem as aj, NavBody as ak, NavFooter as al, NavHeader as am, NavItem as an, NavList as ao, Pagination as ap, Paper as aq, Popover as ar, PopoverAnchor as as, PopoverTrigger as at, Progress as au, Radio as av, RadioGroup as aw, SearchInput as ax, SegmentedControl as ay, SegmentedControlItem as az, AlertDialogAction as b, AlertDialogBody as c, AlertDialogCancel as d, AlertDialogContent as e, AlertDialogFooter as f, AlertDialogHeader as g, AlertDialogTrigger as h, AngleMenuButton as i, Avatar as j, AvatarGroup as k, AxiomProvider as l, Banner as m, Button as n, ButtonGroup as o, DialogBody as p, DialogClose as q, DialogFooter as r, DialogForm as s, DialogHeader as t, DialogTrigger as u, Disclosure as v, DisclosureContent as w, DisclosureTrigger as x, Drawer as y, DrawerActions as z };