raft-ui/dist/index.d.mts

React UI components for Raft.

import { cn } from "./cn.mjs";
import { Dialog as Dialog$1 } from "@base-ui/react/dialog";
import { VariantProps } from "tailwind-variants/lite";
import { ComponentProps, ComponentPropsWithRef, ComponentPropsWithoutRef, CompositionEventHandler, FocusEventHandler, FormEventHandler, HTMLAttributes, KeyboardEventHandler, PointerEvent, ReactNode, RefObject } from "react";
import { Button as Button$1 } from "@base-ui/react/button";
import { useRender } from "@base-ui/react/use-render";
import { Drawer as Drawer$1 } from "@base-ui/react/drawer";
import { Checkbox as Checkbox$1 } from "@base-ui/react/checkbox";
import { ScrollArea as ScrollArea$1 } from "@base-ui/react/scroll-area";
import { Collapsible } from "@base-ui/react/collapsible";
import { Avatar as Avatar$1, ContextMenu as ContextMenu$1 } from "@base-ui/react";
import { Menu } from "@base-ui/react/menu";
import { Tooltip as Tooltip$1 } from "@base-ui/react/tooltip";
import { Popover as Popover$1 } from "@base-ui/react/popover";
import { PreviewCard as PreviewCard$1 } from "@base-ui/react/preview-card";
import { Input as Input$1 } from "@base-ui/react/input";
import { Field as Field$1 } from "@base-ui/react/field";
import { Combobox as Combobox$1 } from "@base-ui/react/combobox";
import { Select as Select$1 } from "@base-ui/react/select";
import { Radio } from "@base-ui/react/radio";
import { RadioGroup as RadioGroup$1 } from "@base-ui/react/radio-group";
import { Switch as Switch$1 } from "@base-ui/react/switch";
import { Toggle } from "@base-ui/react/toggle";
import { ToggleGroup as ToggleGroup$1 } from "@base-ui/react/toggle-group";
import { Toolbar } from "@base-ui/react/toolbar";
import { Progress as Progress$1 } from "@base-ui/react/progress";
import { DragCancelEvent, DragEndEvent, DragMoveEvent, DragOverEvent, DragStartEvent, UniqueIdentifier } from "@dnd-kit/core";
import { Toast } from "@base-ui/react/toast";
import { Tabs as Tabs$1 } from "@base-ui/react/tabs";
import { Separator as Separator$1 } from "@base-ui/react/separator";
import { GroupProps, PanelProps as PanelProps$1, SeparatorProps as SeparatorProps$1 } from "react-resizable-panels";
//#region src/lib/styled-props.d.ts
/**
 * Base UI components type `className` as `string | ((state) => string)`, but our
 * tv() recipes only accept a plain string. `StyledProps` narrows a Base UI
 * component's props to a string `className` so they can flow into a recipe.
 *
 * The state-callback form is intentionally dropped: our components express every
 * state through `data-*` variants in the recipe, so a caller never needs it.
 */
type StyledProps<P> = Omit<P, "className"> & {
  className?: string;
};
//#endregion
//#region src/lib/data-attributes.d.ts
type DataAttributes$1 = Record<`data-${string}`, string | undefined>;
//#endregion
//#region src/components/button/button.d.ts
declare const buttonVariants: import("tailwind-variants/lite").TVReturnType<{
  theme: {
    brutal: {
      root: string[];
    };
    elegant: {
      root: string[];
    };
  };
  variant: {
    primary: {
      root: string[];
    };
    default: {
      root: string[];
    };
    information: {
      root: string[];
    };
    muted: {
      root: string[];
    };
    accent: {
      root: string[];
    };
    warning: {
      root: string[];
    };
    outline: {
      root: string[];
    };
    ghost: {
      root: string[];
    };
    link: {
      root: string[];
    };
    "danger-secondary": {
      root: string[];
    };
    danger: {
      root: string[];
    };
    "danger-outline": {
      root: string[];
    };
  };
  size: {
    xs: {
      root: string[];
    };
    sm: {
      root: string[];
    };
    md: {
      root: string[];
    };
    lg: {
      root: string[];
    };
    "icon-xs": {
      root: string[];
    };
    "icon-sm": {
      root: string[];
    };
    "icon-md": {
      root: string;
    };
    "icon-lg": {
      root: string;
    };
  };
}, {
  root: string[];
  content: string;
  loadingIndicator: string;
}, undefined, {
  theme: {
    brutal: {
      root: string[];
    };
    elegant: {
      root: string[];
    };
  };
  variant: {
    primary: {
      root: string[];
    };
    default: {
      root: string[];
    };
    information: {
      root: string[];
    };
    muted: {
      root: string[];
    };
    accent: {
      root: string[];
    };
    warning: {
      root: string[];
    };
    outline: {
      root: string[];
    };
    ghost: {
      root: string[];
    };
    link: {
      root: string[];
    };
    "danger-secondary": {
      root: string[];
    };
    danger: {
      root: string[];
    };
    "danger-outline": {
      root: string[];
    };
  };
  size: {
    xs: {
      root: string[];
    };
    sm: {
      root: string[];
    };
    md: {
      root: string[];
    };
    lg: {
      root: string[];
    };
    "icon-xs": {
      root: string[];
    };
    "icon-sm": {
      root: string[];
    };
    "icon-md": {
      root: string;
    };
    "icon-lg": {
      root: string;
    };
  };
}, {
  root: string[];
  content: string;
  loadingIndicator: string;
}, import("tailwind-variants/lite").TVReturnTypeLike<{
  theme: {
    brutal: {
      root: string[];
    };
    elegant: {
      root: string[];
    };
  };
  variant: {
    primary: {
      root: string[];
    };
    default: {
      root: string[];
    };
    information: {
      root: string[];
    };
    muted: {
      root: string[];
    };
    accent: {
      root: string[];
    };
    warning: {
      root: string[];
    };
    outline: {
      root: string[];
    };
    ghost: {
      root: string[];
    };
    link: {
      root: string[];
    };
    "danger-secondary": {
      root: string[];
    };
    danger: {
      root: string[];
    };
    "danger-outline": {
      root: string[];
    };
  };
  size: {
    xs: {
      root: string[];
    };
    sm: {
      root: string[];
    };
    md: {
      root: string[];
    };
    lg: {
      root: string[];
    };
    "icon-xs": {
      root: string[];
    };
    "icon-sm": {
      root: string[];
    };
    "icon-md": {
      root: string;
    };
    "icon-lg": {
      root: string;
    };
  };
}, {
  root: string[];
  content: string;
  loadingIndicator: string;
}>>;
type ButtonProps = StyledProps<Button$1.Props> & Omit<VariantProps<typeof buttonVariants>, "theme"> & DataAttributes$1 & {
  loading?: boolean;
  loadingLabel?: string;
};
declare function Button({ variant, size, loading, loadingLabel, disabled, className, children, render, nativeButton, ...props }: ButtonProps): import("react").JSX.Element;
//#endregion
//#region src/components/alert-dialog/alert-dialog.d.ts
type AlertDialogProps = Dialog$1.Root.Props;
declare function AlertDialog(props: AlertDialogProps): import("react").JSX.Element;
type AlertDialogTriggerProps = Dialog$1.Trigger.Props;
declare function AlertDialogTrigger(props: AlertDialogTriggerProps): import("react").JSX.Element;
type AlertDialogPortalProps = Dialog$1.Portal.Props;
declare function AlertDialogPortal(props: AlertDialogPortalProps): import("react").JSX.Element;
type AlertDialogCloseProps = Omit<Dialog$1.Close.Props, "render"> & Pick<ButtonProps, "variant" | "size"> & {
  className?: string;
  children?: ReactNode;
};
declare function AlertDialogClose({ className, variant, size, children, ...props }: AlertDialogCloseProps): import("react").JSX.Element;
type AlertDialogOverlayProps = StyledProps<Dialog$1.Backdrop.Props>;
declare function AlertDialogOverlay({ className, ...props }: AlertDialogOverlayProps): import("react").JSX.Element;
type AlertDialogContentProps = StyledProps<Dialog$1.Popup.Props> & {
  portalProps?: AlertDialogPortalProps;
  overlay?: false | AlertDialogOverlayProps;
};
declare function AlertDialogContent({ className, children, portalProps, overlay, ...props }: AlertDialogContentProps): import("react").JSX.Element;
type AlertDialogHeaderProps = ComponentPropsWithRef<"div">;
declare function AlertDialogHeader({ className, ...props }: AlertDialogHeaderProps): import("react").JSX.Element;
type AlertDialogBodyProps = ComponentPropsWithRef<"div">;
declare function AlertDialogBody({ className, ...props }: AlertDialogBodyProps): import("react").JSX.Element;
type AlertDialogFooterProps = ComponentPropsWithRef<"div">;
declare function AlertDialogFooter({ className, ...props }: AlertDialogFooterProps): import("react").JSX.Element;
type AlertDialogTitleProps = StyledProps<Dialog$1.Title.Props>;
declare function AlertDialogTitle({ className, ...props }: AlertDialogTitleProps): import("react").JSX.Element;
type AlertDialogDescriptionProps = StyledProps<Dialog$1.Description.Props>;
declare function AlertDialogDescription({ className, ...props }: AlertDialogDescriptionProps): import("react").JSX.Element;
type AlertDialogActionProps = ButtonProps;
declare function AlertDialogAction(props: AlertDialogActionProps): import("react").JSX.Element;
type AlertDialogCancelProps = Omit<Dialog$1.Close.Props, "render"> & Pick<ButtonProps, "variant" | "size"> & {
  className?: string;
};
declare function AlertDialogCancel({ className, variant, size, ...props }: AlertDialogCancelProps): import("react").JSX.Element;
//#endregion
//#region src/components/dialog/dialog.d.ts
type DialogProps = Dialog$1.Root.Props;
declare function Dialog(props: DialogProps): import("react").JSX.Element;
type DialogTriggerProps = Dialog$1.Trigger.Props;
declare function DialogTrigger(props: DialogTriggerProps): import("react").JSX.Element;
type DialogPortalProps = Dialog$1.Portal.Props;
declare function DialogPortal(props: DialogPortalProps): import("react").JSX.Element;
type DialogOverlayProps = StyledProps<Dialog$1.Backdrop.Props>;
declare function DialogOverlay({ className, ...props }: DialogOverlayProps): import("react").JSX.Element;
type DialogContentProps = StyledProps<Dialog$1.Popup.Props> & {
  portalProps?: DialogPortalProps;
  overlay?: false | DialogOverlayProps;
};
declare function DialogContent({ className, children, portalProps, overlay, ...props }: DialogContentProps): import("react").JSX.Element;
type DialogCloseProps = Dialog$1.Close.Props & Pick<ButtonProps, "variant" | "size"> & {
  className?: string;
  children?: ReactNode;
};
declare function DialogClose({ className, variant, size, children, render, ...props }: DialogCloseProps): import("react").JSX.Element;
type DialogHeaderProps = ComponentPropsWithRef<"div">;
declare function DialogHeader({ className, ...props }: DialogHeaderProps): import("react").JSX.Element;
type DialogBodyProps = ComponentPropsWithRef<"div">;
declare function DialogBody({ className, ...props }: DialogBodyProps): import("react").JSX.Element;
type DialogFooterProps = ComponentPropsWithRef<"div">;
declare function DialogFooter({ className, ...props }: DialogFooterProps): import("react").JSX.Element;
type DialogTitleProps = StyledProps<Dialog$1.Title.Props>;
declare function DialogTitle({ className, ...props }: DialogTitleProps): import("react").JSX.Element;
type DialogDescriptionProps = StyledProps<Dialog$1.Description.Props>;
declare function DialogDescription({ className, ...props }: DialogDescriptionProps): import("react").JSX.Element;
//#endregion
//#region src/components/drawer/drawer.d.ts
type DrawerProps = Drawer$1.Root.Props;
declare function Drawer({ modal, snapPoints, swipeDirection, ...props }: DrawerProps): import("react").JSX.Element;
type DrawerTriggerProps = Drawer$1.Trigger.Props;
declare function DrawerTrigger(props: DrawerTriggerProps): import("react").JSX.Element;
type DrawerPortalProps = Drawer$1.Portal.Props;
declare function DrawerPortal(props: DrawerPortalProps): import("react").JSX.Element;
type DrawerOverlayProps = StyledProps<Drawer$1.Backdrop.Props>;
declare function DrawerOverlay({ className, ...props }: DrawerOverlayProps): import("react").JSX.Element;
type DrawerContentProps = StyledProps<Drawer$1.Popup.Props> & {
  portalProps?: DrawerPortalProps;
};
declare function DrawerContent({ className, children, portalProps, ...props }: DrawerContentProps): import("react").JSX.Element;
type DrawerCloseProps = StyledProps<Drawer$1.Close.Props> & Pick<ButtonProps, "variant" | "size">;
declare function DrawerClose({ className, variant, size, children, render, ...props }: DrawerCloseProps): import("react").JSX.Element;
type DrawerHeaderProps = useRender.ComponentProps<"div">;
declare function DrawerHeader({ className, render, ...props }: DrawerHeaderProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type DrawerFooterProps = useRender.ComponentProps<"div">;
declare function DrawerFooter({ className, render, ...props }: DrawerFooterProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type DrawerBodyProps = useRender.ComponentProps<"div">;
declare function DrawerBody({ className, render, ...props }: DrawerBodyProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type DrawerActionsProps = useRender.ComponentProps<"div">;
declare function DrawerActions({ className, render, children, ...props }: DrawerActionsProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type DrawerTitleProps = StyledProps<Drawer$1.Title.Props>;
declare function DrawerTitle({ className, ...props }: DrawerTitleProps): import("react").JSX.Element;
type DrawerDescriptionProps = StyledProps<Drawer$1.Description.Props>;
declare function DrawerDescription({ className, ...props }: DrawerDescriptionProps): import("react").JSX.Element;
//#endregion
//#region src/components/card/card.recipe.d.ts
declare const card: import("tailwind-variants/lite").TVReturnType<{
  theme: {
    brutal: {
      leading: string[];
      title: string[];
      description: string[];
      footer: string[];
    };
    elegant: {
      leading: string[];
      title: string[];
      description: string[];
      footer: string[];
    };
  };
  variant: {
    default: {};
    inset: {};
  };
}, {
  root: string[];
  header: string[];
  title: string[];
  leading: string[];
  description: string[];
  trailing: string[];
  content: string[];
  footer: string[];
}, undefined, {
  theme: {
    brutal: {
      leading: string[];
      title: string[];
      description: string[];
      footer: string[];
    };
    elegant: {
      leading: string[];
      title: string[];
      description: string[];
      footer: string[];
    };
  };
  variant: {
    default: {};
    inset: {};
  };
}, {
  root: string[];
  header: string[];
  title: string[];
  leading: string[];
  description: string[];
  trailing: string[];
  content: string[];
  footer: string[];
}, import("tailwind-variants/lite").TVReturnTypeLike<{
  theme: {
    brutal: {
      leading: string[];
      title: string[];
      description: string[];
      footer: string[];
    };
    elegant: {
      leading: string[];
      title: string[];
      description: string[];
      footer: string[];
    };
  };
  variant: {
    default: {};
    inset: {};
  };
}, {
  root: string[];
  header: string[];
  title: string[];
  leading: string[];
  description: string[];
  trailing: string[];
  content: string[];
  footer: string[];
}>>;
//#endregion
//#region src/components/card/card.d.ts
type CardProps = useRender.ComponentProps<"div"> & Omit<VariantProps<typeof card>, "theme">;
declare function Card({ className, render, variant, ...props }: CardProps): import("react").JSX.Element;
type CardHeaderProps = useRender.ComponentProps<"div">;
declare function CardHeader({ className, render, ...props }: CardHeaderProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type CardTitleProps = useRender.ComponentProps<"div">;
declare function CardTitle({ className, render, ...props }: CardTitleProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type CardLeadingProps = useRender.ComponentProps<"div">;
declare function CardLeading({ className, render, ...props }: CardLeadingProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type CardDescriptionProps = useRender.ComponentProps<"div">;
declare function CardDescription({ className, render, ...props }: CardDescriptionProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type CardTrailingProps = useRender.ComponentProps<"div">;
declare function CardTrailing({ className, render, ...props }: CardTrailingProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type CardContentProps = useRender.ComponentProps<"div">;
declare function CardContent({ className, render, ...props }: CardContentProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type CardFooterProps = useRender.ComponentProps<"div">;
declare function CardFooter({ className, render, ...props }: CardFooterProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/status/status.d.ts
declare const status$1: import("tailwind-variants/lite").TVReturnType<{
  theme: {
    brutal: {};
    elegant: {};
  };
  size: {
    xs: {
      root: string;
    };
    sm: {
      root: string;
    };
    md: {
      root: string;
    };
    lg: {
      root: string;
    };
  };
  pulse: {
    true: {
      root: string;
    };
    false: {
      root: string;
    };
  };
  attention: {
    true: {
      root: string;
    };
    false: {
      root: string;
    };
  };
}, undefined, undefined, {
  theme: {
    brutal: {
      root: string;
    };
    elegant: {};
  };
  variant: {
    default: {
      root: string;
    };
    primary: {
      root: string;
    };
    information: {
      root: string;
    };
    muted: {
      root: string;
    };
    accent: {
      root: string;
    };
    success: {
      root: string;
    };
    warning: {
      root: string;
    };
    danger: {
      root: string;
    };
  };
}, {
  root: string[];
}, import("tailwind-variants/lite").TVReturnType<{
  theme: {
    brutal: {
      root: string;
    };
    elegant: {};
  };
  variant: {
    default: {
      root: string;
    };
    primary: {
      root: string;
    };
    information: {
      root: string;
    };
    muted: {
      root: string;
    };
    accent: {
      root: string;
    };
    success: {
      root: string;
    };
    warning: {
      root: string;
    };
    danger: {
      root: string;
    };
  };
}, {
  root: string[];
}, undefined, {
  theme: {
    brutal: {
      root: string;
    };
    elegant: {};
  };
  variant: {
    default: {
      root: string;
    };
    primary: {
      root: string;
    };
    information: {
      root: string;
    };
    muted: {
      root: string;
    };
    accent: {
      root: string;
    };
    success: {
      root: string;
    };
    warning: {
      root: string;
    };
    danger: {
      root: string;
    };
  };
}, {
  root: string[];
}, import("tailwind-variants/lite").TVReturnTypeLike<{
  theme: {
    brutal: {
      root: string;
    };
    elegant: {};
  };
  variant: {
    default: {
      root: string;
    };
    primary: {
      root: string;
    };
    information: {
      root: string;
    };
    muted: {
      root: string;
    };
    accent: {
      root: string;
    };
    success: {
      root: string;
    };
    warning: {
      root: string;
    };
    danger: {
      root: string;
    };
  };
}, {
  root: string[];
}>>>;
type StatusProps = Omit<useRender.ComponentProps<"span">, "children"> & Omit<VariantProps<typeof status$1>, "theme">;
declare function StatusRoot({ size, variant, pulse, attention, className, render, ...props }: StatusProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
declare const Status: typeof StatusRoot;
//#endregion
//#region src/components/app-rail/app-rail.d.ts
type AppRailRootProps = useRender.ComponentProps<"div">;
declare function AppRailRoot({ className, render, ...props }: AppRailRootProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type AppRailHeaderProps = useRender.ComponentProps<"div">;
declare function AppRailHeader({ className, render, ...props }: AppRailHeaderProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type AppRailNavProps = useRender.ComponentProps<"nav">;
declare function AppRailNav({ className, render, ...props }: AppRailNavProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type AppRailItemProps = useRender.ComponentProps<"button"> & {
  nativeButton?: boolean;
  selected?: boolean;
};
declare function AppRailItem({ nativeButton, selected, disabled, className, render, ...props }: AppRailItemProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type AppRailItemIconProps = useRender.ComponentProps<"span">;
declare function AppRailItemIcon({ className, render, ...props }: AppRailItemIconProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type AppRailItemAttentionProps = {
  title?: string;
  children: ReactNode;
};
declare function AppRailItemAttention({ title, children }: AppRailItemAttentionProps): import("react").JSX.Element;
type AppRailItemAttentionMaskProps = useRender.ComponentProps<"span">;
declare function AppRailItemAttentionMask({ className, render, ...props }: AppRailItemAttentionMaskProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type AppRailItemLabelProps = useRender.ComponentProps<"span">;
declare function AppRailItemLabel({ className, render, ...props }: AppRailItemLabelProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type AppRailItemBadgeProps = useRender.ComponentProps<"span">;
declare function AppRailItemBadge({ className, render, ...props }: AppRailItemBadgeProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type AppRailItemIndicatorProps = StatusProps;
declare function AppRailItemIndicator({ className, size, variant, attention, ...props }: AppRailItemIndicatorProps): import("react").JSX.Element;
type AppRailFooterProps = useRender.ComponentProps<"div">;
declare function AppRailFooter({ className, render, ...props }: AppRailFooterProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/copyable-code/copyable-code.d.ts
declare const copyableCode: import("tailwind-variants/lite").TVReturnType<{
  theme: {
    brutal: {
      code: string[];
      codeInner: string;
    };
    elegant: {
      code: string[];
      codeInner: string[];
      action: string[];
    };
  };
  size: {
    sm: {
      code: string;
    };
    md: {
      code: string;
    };
  };
}, {
  root: string[];
  code: string[];
  codeInner: string[];
  action: string[];
  iconSwap: string[];
}, undefined, {
  theme: {
    brutal: {
      code: string[];
      codeInner: string;
    };
    elegant: {
      code: string[];
      codeInner: string[];
      action: string[];
    };
  };
  size: {
    sm: {
      code: string;
    };
    md: {
      code: string;
    };
  };
}, {
  root: string[];
  code: string[];
  codeInner: string[];
  action: string[];
  iconSwap: string[];
}, import("tailwind-variants/lite").TVReturnTypeLike<{
  theme: {
    brutal: {
      code: string[];
      codeInner: string;
    };
    elegant: {
      code: string[];
      codeInner: string[];
      action: string[];
    };
  };
  size: {
    sm: {
      code: string;
    };
    md: {
      code: string;
    };
  };
}, {
  root: string[];
  code: string[];
  codeInner: string[];
  action: string[];
  iconSwap: string[];
}>>;
type CopyableCodeRootProps = Omit<ComponentPropsWithRef<"div">, "onCopy"> & Pick<VariantProps<typeof copyableCode>, "size"> & {
  copied?: boolean;
  onCopy?: (value: string) => void | Promise<void>;
};
declare function CopyableCodeRoot({ copied, onCopy, size, className, ...props }: CopyableCodeRootProps): import("react").JSX.Element;
type CopyableCodeProps = ComponentPropsWithRef<"code"> & {
  truncate?: boolean;
};
declare function CopyableCode({ children, className, truncate, ...props }: CopyableCodeProps): import("react").JSX.Element;
type CopyableCodeActionProps = Omit<ButtonProps, "children" | "className"> & {
  buttonClassName?: string;
  className?: string;
  children?: ReactNode | ((state: {
    copied: boolean;
  }) => ReactNode);
};
declare function CopyableCodeAction({ children, buttonClassName, className, onClick, size, variant, ...props }: CopyableCodeActionProps): import("react").JSX.Element;
//#endregion
//#region src/components/checkbox/checkbox.d.ts
declare const checkbox: import("tailwind-variants/lite").TVReturnType<{
  theme: {
    brutal: {};
    elegant: {
      root: string[];
      graphic: string[];
    };
  };
  variant: {
    default: {};
    primary: {};
  };
  color: {
    default: {};
    primary: {};
  };
  size: {
    sm: {
      root: string;
    };
    md: {
      root: string;
    };
    lg: {
      root: string;
    };
  };
}, {
  root: string[];
  indicator: string[];
  graphic: string[];
  outerRect: string[];
  overlayRect: string[];
  mark: string[];
  checkMark: string[];
  indeterminateMark: string[];
}, undefined, {
  theme: {
    brutal: {};
    elegant: {
      root: string[];
      graphic: string[];
    };
  };
  variant: {
    default: {};
    primary: {};
  };
  color: {
    default: {};
    primary: {};
  };
  size: {
    sm: {
      root: string;
    };
    md: {
      root: string;
    };
    lg: {
      root: string;
    };
  };
}, {
  root: string[];
  indicator: string[];
  graphic: string[];
  outerRect: string[];
  overlayRect: string[];
  mark: string[];
  checkMark: string[];
  indeterminateMark: string[];
}, import("tailwind-variants/lite").TVReturnTypeLike<{
  theme: {
    brutal: {};
    elegant: {
      root: string[];
      graphic: string[];
    };
  };
  variant: {
    default: {};
    primary: {};
  };
  color: {
    default: {};
    primary: {};
  };
  size: {
    sm: {
      root: string;
    };
    md: {
      root: string;
    };
    lg: {
      root: string;
    };
  };
}, {
  root: string[];
  indicator: string[];
  graphic: string[];
  outerRect: string[];
  overlayRect: string[];
  mark: string[];
  checkMark: string[];
  indeterminateMark: string[];
}>>;
type CheckboxProps = StyledProps<Checkbox$1.Root.Props> & Omit<VariantProps<typeof checkbox>, "theme"> & {
  shape?: "square" | "circle";
};
declare function Checkbox({ size, color, variant, shape, className, ...props }: CheckboxProps): import("react").JSX.Element;
//#endregion
//#region src/components/sidebar/sidebar.d.ts
type SidebarRootProps = useRender.ComponentProps<"div">;
declare function SidebarRoot({ className, render, ...props }: SidebarRootProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarHeaderProps = useRender.ComponentProps<"div">;
declare function SidebarHeader({ children, className, render, ...props }: SidebarHeaderProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarHeaderTitleProps = useRender.ComponentProps<"div">;
declare function SidebarHeaderTitle({ className, render, ...props }: SidebarHeaderTitleProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarGroupLabelProps = useRender.ComponentProps<"div">;
declare function SidebarGroupLabel({ className, render, ...props }: SidebarGroupLabelProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarBodyProps = useRender.ComponentProps<"div">;
declare function SidebarBody({ className, render, ...props }: SidebarBodyProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarContentProps = useRender.ComponentProps<"div">;
declare function SidebarContent({ children, className, render, ...props }: SidebarContentProps): import("react").JSX.Element;
type SidebarLiveActivityProps = useRender.ComponentProps<"div">;
declare function SidebarLiveActivity({ children, className, render, ...props }: SidebarLiveActivityProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/sidebar/sidebar-menu.d.ts
type SidebarMenuProps = useRender.ComponentProps<"button">;
declare function SidebarMenu({ className, render, ...props }: SidebarMenuProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarMenuIconProps = useRender.ComponentProps<"span">;
declare function SidebarMenuIcon({ className, render, ...props }: SidebarMenuIconProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarMenuTitleProps = useRender.ComponentProps<"span">;
declare function SidebarMenuTitle({ className, render, ...props }: SidebarMenuTitleProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarMenuAsideProps = useRender.ComponentProps<"span">;
declare function SidebarMenuAside({ className, render, ...props }: SidebarMenuAsideProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarMenuCountProps = useRender.ComponentProps<"span">;
declare function SidebarMenuCount({ className, render, ...props }: SidebarMenuCountProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/badge/badge.d.ts
declare const badge: import("tailwind-variants/lite").TVReturnType<{
  theme: {
    brutal: {
      root: string[];
    };
    elegant: {
      root: string[];
    };
  };
  appearance: {
    solid: {
      root: string;
    };
    soft: {
      root: string;
    };
    outline: {
      root: string;
    };
  };
  variant: {
    default: {
      root: string;
    };
    primary: {
      root: string;
    };
    information: {
      root: string;
    };
    muted: {
      root: string;
    };
    accent: {
      root: string;
    };
    success: {
      root: string;
    };
    warning: {
      root: string;
    };
    danger: {
      root: string;
    };
  };
  uppercase: {
    true: {
      root: string;
    };
    false: {
      root: string;
    };
  };
}, {
  root: string[];
}, undefined, {
  theme: {
    brutal: {
      root: string[];
    };
    elegant: {
      root: string[];
    };
  };
  appearance: {
    solid: {
      root: string;
    };
    soft: {
      root: string;
    };
    outline: {
      root: string;
    };
  };
  variant: {
    default: {
      root: string;
    };
    primary: {
      root: string;
    };
    information: {
      root: string;
    };
    muted: {
      root: string;
    };
    accent: {
      root: string;
    };
    success: {
      root: string;
    };
    warning: {
      root: string;
    };
    danger: {
      root: string;
    };
  };
  uppercase: {
    true: {
      root: string;
    };
    false: {
      root: string;
    };
  };
}, {
  root: string[];
}, import("tailwind-variants/lite").TVReturnTypeLike<{
  theme: {
    brutal: {
      root: string[];
    };
    elegant: {
      root: string[];
    };
  };
  appearance: {
    solid: {
      root: string;
    };
    soft: {
      root: string;
    };
    outline: {
      root: string;
    };
  };
  variant: {
    default: {
      root: string;
    };
    primary: {
      root: string;
    };
    information: {
      root: string;
    };
    muted: {
      root: string;
    };
    accent: {
      root: string;
    };
    success: {
      root: string;
    };
    warning: {
      root: string;
    };
    danger: {
      root: string;
    };
  };
  uppercase: {
    true: {
      root: string;
    };
    false: {
      root: string;
    };
  };
}, {
  root: string[];
}>>;
type BadgeProps = useRender.ComponentProps<"span"> & Omit<VariantProps<typeof badge>, "theme">;
declare function BadgeRoot({ appearance, variant, uppercase, className, render, ...props }: BadgeProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
declare function Experimental(props: Omit<BadgeProps, "appearance" | "variant" | "uppercase">): import("react").JSX.Element;
declare const Badge: typeof BadgeRoot & {
  Experimental: typeof Experimental;
};
//#endregion
//#region src/components/sidebar/sidebar-item.recipe.d.ts
declare const sidebarItemRecipe: import("tailwind-variants/lite").TVReturnType<{
  theme: {
    brutal: {
      sidebarItem: string[];
      sidebarItemTitle: string;
      sidebarItemChannelIcon: string;
      sidebarItemSubtitle: string;
      sidebarItemMeta: string[];
      sidebarItemStatus: string[];
      sidebarItemIndicator: string[];
      sidebarItemMetaIcon: string;
      sidebarItemCount: string[];
    };
    elegant: {
      sidebarItem: string[];
      sidebarItemTitle: string;
      sidebarItemIcon: string;
      sidebarItemChannelIcon: string;
      sidebarItemSubtitle: string;
      sidebarItemMeta: string[];
      sidebarItemStatus: string[];
      sidebarItemIndicator: string[];
      sidebarItemMetaIcon: string;
      sidebarItemCount: string[];
    };
  };
  variant: {
    default: {};
    primary: {};
    accent: {};
  };
  stacked: {
    false: {
      sidebarItemContent: string[];
    };
    true: {
      sidebarItemContent: string[];
    };
  };
}, {
  sidebarItem: string[];
  sidebarItemIcon: string[];
  sidebarItemChannelIcon: string[];
  sidebarItemContent: string[];
  sidebarItemTitle: string[];
  sidebarItemSubtitle: string[];
  sidebarItemMeta: string[];
  sidebarItemStatus: string[];
  sidebarItemIndicator: string[];
  sidebarItemMetaIcon: string[];
  sidebarItemAside: string[];
  sidebarItemCount: string[];
}, undefined, {
  theme: {
    brutal: {
      sidebarItem: string[];
      sidebarItemTitle: string;
      sidebarItemChannelIcon: string;
      sidebarItemSubtitle: string;
      sidebarItemMeta: string[];
      sidebarItemStatus: string[];
      sidebarItemIndicator: string[];
      sidebarItemMetaIcon: string;
      sidebarItemCount: string[];
    };
    elegant: {
      sidebarItem: string[];
      sidebarItemTitle: string;
      sidebarItemIcon: string;
      sidebarItemChannelIcon: string;
      sidebarItemSubtitle: string;
      sidebarItemMeta: string[];
      sidebarItemStatus: string[];
      sidebarItemIndicator: string[];
      sidebarItemMetaIcon: string;
      sidebarItemCount: string[];
    };
  };
  variant: {
    default: {};
    primary: {};
    accent: {};
  };
  stacked: {
    false: {
      sidebarItemContent: string[];
    };
    true: {
      sidebarItemContent: string[];
    };
  };
}, {
  sidebarItem: string[];
  sidebarItemIcon: string[];
  sidebarItemChannelIcon: string[];
  sidebarItemContent: string[];
  sidebarItemTitle: string[];
  sidebarItemSubtitle: string[];
  sidebarItemMeta: string[];
  sidebarItemStatus: string[];
  sidebarItemIndicator: string[];
  sidebarItemMetaIcon: string[];
  sidebarItemAside: string[];
  sidebarItemCount: string[];
}, import("tailwind-variants/lite").TVReturnTypeLike<{
  theme: {
    brutal: {
      sidebarItem: string[];
      sidebarItemTitle: string;
      sidebarItemChannelIcon: string;
      sidebarItemSubtitle: string;
      sidebarItemMeta: string[];
      sidebarItemStatus: string[];
      sidebarItemIndicator: string[];
      sidebarItemMetaIcon: string;
      sidebarItemCount: string[];
    };
    elegant: {
      sidebarItem: string[];
      sidebarItemTitle: string;
      sidebarItemIcon: string;
      sidebarItemChannelIcon: string;
      sidebarItemSubtitle: string;
      sidebarItemMeta: string[];
      sidebarItemStatus: string[];
      sidebarItemIndicator: string[];
      sidebarItemMetaIcon: string;
      sidebarItemCount: string[];
    };
  };
  variant: {
    default: {};
    primary: {};
    accent: {};
  };
  stacked: {
    false: {
      sidebarItemContent: string[];
    };
    true: {
      sidebarItemContent: string[];
    };
  };
}, {
  sidebarItem: string[];
  sidebarItemIcon: string[];
  sidebarItemChannelIcon: string[];
  sidebarItemContent: string[];
  sidebarItemTitle: string[];
  sidebarItemSubtitle: string[];
  sidebarItemMeta: string[];
  sidebarItemStatus: string[];
  sidebarItemIndicator: string[];
  sidebarItemMetaIcon: string[];
  sidebarItemAside: string[];
  sidebarItemCount: string[];
}>>;
//#endregion
//#region src/components/sidebar/sidebar-item.d.ts
type SidebarItemRootProps = useRender.ComponentProps<"button"> & {
  active?: boolean;
};
type SidebarItemVariant = NonNullable<VariantProps<typeof sidebarItemRecipe>["variant"]>;
type SidebarItemProps = SidebarItemRootProps & Pick<VariantProps<typeof sidebarItemRecipe>, "variant">;
declare function SidebarItem({ className, variant, ...props }: SidebarItemProps): import("react").JSX.Element;
type SidebarItemIconProps = useRender.ComponentProps<"span">;
declare function SidebarItemIcon({ className, render, ...props }: SidebarItemIconProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarItemChannelIconProps = useRender.ComponentProps<"span">;
declare function SidebarItemChannelIcon({ className, render, ...props }: SidebarItemChannelIconProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarItemContentProps = useRender.ComponentProps<"span"> & {
  stacked?: boolean;
};
declare function SidebarItemContent({ className, render, stacked, ...props }: SidebarItemContentProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarItemTitleProps = useRender.ComponentProps<"span">;
declare function SidebarItemTitle({ className, render, ...props }: SidebarItemTitleProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarItemSubtitleProps = useRender.ComponentProps<"span">;
declare function SidebarItemSubtitle({ className, render, ...props }: SidebarItemSubtitleProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarItemMetaProps = useRender.ComponentProps<"span">;
declare function SidebarItemMeta({ className, render, ...props }: SidebarItemMetaProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarItemStatusProps = useRender.ComponentProps<"span">;
declare function SidebarItemStatus({ className, render, ...props }: SidebarItemStatusProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarItemIndicatorProps = BadgeProps;
declare function SidebarItemIndicator({ appearance, className, uppercase, variant, ...props }: SidebarItemIndicatorProps): import("react").JSX.Element;
type SidebarItemMetaIconProps = useRender.ComponentProps<"span">;
declare function SidebarItemMetaIcon({ className, render, ...props }: SidebarItemMetaIconProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarItemAsideProps = useRender.ComponentProps<"span">;
declare function SidebarItemAside({ className, render, ...props }: SidebarItemAsideProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarItemCountProps = BadgeProps;
declare function SidebarItemCount({ appearance, className, uppercase, variant, ...props }: SidebarItemCountProps): import("react").JSX.Element;
//#endregion
//#region src/components/sidebar/sidebar-section.d.ts
type SidebarSectionProps = Omit<ComponentProps<typeof Collapsible.Root>, "className"> & {
  className?: string;
};
declare function SidebarSection({ className, defaultOpen, render, ...props }: SidebarSectionProps): import("react").JSX.Element;
type SidebarListProps = Omit<ComponentProps<typeof Collapsible.Panel>, "className"> & {
  className?: string;
};
declare function SidebarList({ className, render, ...props }: SidebarListProps): import("react").JSX.Element;
type SidebarSectionEmptyProps = Omit<ComponentProps<typeof Collapsible.Panel>, "className"> & {
  className?: string;
};
declare function SidebarSectionEmpty({ className, render, ...props }: SidebarSectionEmptyProps): import("react").JSX.Element;
type SidebarSectionHeaderProps = useRender.ComponentProps<"div">;
declare function SidebarSectionHeader({ className, render, ...props }: SidebarSectionHeaderProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarSectionDisclosureProps = useRender.ComponentProps<"button">;
declare function SidebarSectionDisclosure({ className, render, ...props }: SidebarSectionDisclosureProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarSectionChevronProps = useRender.ComponentProps<"svg">;
declare function SidebarSectionChevron({ className, render, ...props }: SidebarSectionChevronProps): import("react").JSX.Element;
type SidebarSectionTitleProps = useRender.ComponentProps<"span">;
declare function SidebarSectionTitle({ className, render, ...props }: SidebarSectionTitleProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarSectionCountProps = useRender.ComponentProps<"span">;
declare function SidebarSectionCount({ className, render, ...props }: SidebarSectionCountProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarSectionAttentionProps = StatusProps;
declare function SidebarSectionAttention({ className, size, variant, ...props }: SidebarSectionAttentionProps): import("react").JSX.Element;
type SidebarSectionTrailingProps = useRender.ComponentProps<"div">;
type SidebarSectionControlsProps = useRender.ComponentProps<"div">;
declare function SidebarSectionTrailing({ className, render, ...props }: SidebarSectionTrailingProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
declare function SidebarSectionControls({ className, render, ...props }: SidebarSectionControlsProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarSectionControlProps = useRender.ComponentProps<"button"> & Pick<ButtonProps, "size" | "variant" | "loading" | "loadingLabel">;
declare function SidebarSectionControl({ className, render, size, variant, loading, loadingLabel, children, disabled, ...props }: SidebarSectionControlProps): import("react").JSX.Element;
type SidebarControlProps = SidebarSectionControlProps;
declare const SidebarControl: typeof SidebarSectionControl;
//#endregion
//#region src/components/panel/panel.d.ts
type PanelEdge = "attached" | "inset";
type PanelProps = useRender.ComponentProps<"section"> & {
  edge?: PanelEdge;
};
declare function Panel({ className, edge, render, ...props }: PanelProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type PanelHeaderRootProps = useRender.ComponentProps<"div">;
/**
 * Bare header bar: fixed height and centered flex row, no border, fill, or padding.
 * Shared base for `PanelHeader`, `PanelSectionHeader`, and panel-specific headers
 * such as `ThreadPanelHeader` — it is not exclusive to `PanelHeader`.
 */
declare function PanelHeaderRoot({ className, render, ...props }: PanelHeaderRootProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type PanelBodyProps = useRender.ComponentProps<"div">;
declare function PanelBody({ className, render, ...props }: PanelBodyProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type PanelScrollViewportProps = useRender.ComponentProps<"div">;
declare function PanelScrollViewport({ className, render, ...props }: PanelScrollViewportProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type PanelScrollContentProps = useRender.ComponentProps<"div">;
declare function PanelScrollContent({ className, render, ...props }: PanelScrollContentProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type PanelSectionProps = useRender.ComponentProps<"section">;
declare function PanelSection({ className, render, ...props }: PanelSectionProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type PanelFooterProps = useRender.ComponentProps<"div">;
declare function PanelFooter({ className, render, ...props }: PanelFooterProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/conversation-panel/conversation-panel.d.ts
type ConversationPanelRootProps = useRender.ComponentProps<"section"> & {
  edge?: PanelEdge;
};
declare function ConversationPanelRoot({ className, edge, render, ...props }: ConversationPanelRootProps): import("react").JSX.Element;
type ConversationPanelContentProps = useRender.ComponentProps<"div">;
/**
 * Content region below the conversation header. A single container hosting tabs,
 * body, and footer; elegant mobile sits flush to the bottom with top radius
 * and top gap only; desktop keeps the left inset / rounded-tl treatment.
 */
declare function ConversationPanelContent({ className, render, ...props }: ConversationPanelContentProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type ConversationPanelBodyProps = useRender.ComponentProps<"div">;
declare function ConversationPanelBody({ className, render, ...props }: ConversationPanelBodyProps): import("react").JSX.Element;
type ConversationPanelTabsProps = useRender.ComponentProps<"div">;
declare function ConversationPanelTabs({ className, render, ...props }: ConversationPanelTabsProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type ConversationPanelFooterProps = useRender.ComponentProps<"div">;
declare function ConversationPanelFooter({ className, render, ...props }: ConversationPanelFooterProps): import("react").JSX.Element;
//#endregion
//#region src/components/conversation-panel/conversation-panel-empty-state.d.ts
type ConversationPanelEmptyStateProps = useRender.ComponentProps<"div">;
declare function ConversationPanelEmptyState({ className, render, ...props }: ConversationPanelEmptyStateProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type ConversationPanelEmptyStateBrandProps = useRender.ComponentProps<"div">;
declare function ConversationPanelEmptyStateBrand({ className, render, ...props }: ConversationPanelEmptyStateBrandProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type ConversationPanelEmptyStateBrandMarkProps = useRender.ComponentProps<"div">;
declare function ConversationPanelEmptyStateBrandMark({ className, render, ...props }: ConversationPanelEmptyStateBrandMarkProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/kbd/kbd.d.ts
type KbdProps = ComponentPropsWithRef<"kbd">;
declare function Kbd({ className, ...props }: KbdProps): import("react").JSX.Element;
type KbdGroupProps = ComponentPropsWithRef<"span">;
declare function KbdGroup({ className, ...props }: KbdGroupProps): import("react").JSX.Element;
//#endregion
//#region src/components/context-menu/context-menu.d.ts
type ContextMenuProps = ContextMenu$1.Root.Props;
declare function ContextMenu(props: ContextMenuProps): import("react").JSX.Element;
type ContextMenuSubmenuProps = ContextMenu$1.SubmenuRoot.Props;
declare function ContextMenuSubmenu(props: ContextMenuSubmenuProps): import("react").JSX.Element;
type ContextMenuTriggerProps = StyledProps<ContextMenu$1.Trigger.Props>;
declare function ContextMenuTrigger({ className, ...props }: ContextMenuTriggerProps): import("react").JSX.Element;
type ContextMenuPortalProps = ContextMenu$1.Portal.Props;
declare function ContextMenuPortal(props: ContextMenuPortalProps): import("react").JSX.Element;
type ContextMenuContentProps = StyledProps<ContextMenu$1.Popup.Props> & Partial<Pick<ContextMenu$1.Positioner.Props, "align" | "alignOffset" | "anchor" | "arrowPadding" | "collisionAvoidance" | "collisionBoundary" | "collisionPadding" | "disableAnchorTracking" | "positionMethod" | "side" | "sideOffset" | "sticky">> & {
  portalProps?: ContextMenuPortalProps;
};
declare function ContextMenuContent({ align, alignOffset, anchor, arrowPadding, collisionAvoidance, collisionBoundary, collisionPadding, disableAnchorTracking, positionMethod, side, sideOffset, sticky, portalProps, className, ...props }: ContextMenuContentProps): import("react").JSX.Element;
type ContextMenuPopupProps = ComponentPropsWithRef<"div">;
declare function ContextMenuPopup({ className, ...props }: ContextMenuPopupProps): import("react").JSX.Element;
type ContextMenuItemProps = StyledProps<ContextMenu$1.Item.Props>;
declare function ContextMenuItem({ className, ...props }: ContextMenuItemProps): import("react").JSX.Element;
type ContextMenuItemLabelProps = StyledProps<ComponentPropsWithRef<"span">>;
declare function ContextMenuItemLabel({ className, ...props }: ContextMenuItemLabelProps): import("react").JSX.Element;
type ContextMenuFooterProps = StyledProps<ComponentPropsWithRef<"div">>;
declare function ContextMenuFooter({ className, ...pr