raft-ui/dist/index.d.mts

React UI components for Raft.

import { $ as SidebarItemProps, A as PanelScrollContent, B as SidebarItemChannelIconProps, C as PanelBodyProps, Ct as Button, D as PanelHeaderRoot, Dt as DataAttributes$1, E as PanelFooterProps, Et as VariantProps, F as PanelSectionProps, G as SidebarItemIcon, H as SidebarItemContentProps, I as SidebarItem, J as SidebarItemIndicatorProps, K as SidebarItemIconProps, L as SidebarItemAside, M as PanelScrollViewport, N as PanelScrollViewportProps, O as PanelHeaderRootProps, Ot as StyledProps, P as PanelSection, Q as SidebarItemMetaProps, R as SidebarItemAsideProps, S as PanelBody, St as SidebarRootProps, T as PanelFooter, Tt as buttonVariants, U as SidebarItemCount, V as SidebarItemContent, W as SidebarItemCountProps, X as SidebarItemMetaIcon, Y as SidebarItemMeta, Z as SidebarItemMetaIconProps, _ as PanelStatus, _t as SidebarHeaderTitle, a as PanelHeader, at as SidebarItemTitle, b as PanelTitleProps, bt as SidebarLiveActivityProps, c as PanelHeaderIcon, ct as BadgeProps, d as PanelHeading, dt as SidebarContent, f as PanelHeadingProps, ft as SidebarContentProps, g as PanelSectionHeaderProps, gt as SidebarHeaderProps, h as PanelSectionHeader, ht as SidebarHeader, i as PanelActivityProps, it as SidebarItemSubtitleProps, j as PanelScrollContentProps, k as PanelProps, l as PanelHeaderIconProps, lt as SidebarBody, m as PanelMetaProps, mt as SidebarGroupLabelProps, n as PanelActionsProps, nt as SidebarItemStatusProps, o as PanelHeaderContent, ot as SidebarItemTitleProps, p as PanelMeta, pt as SidebarGroupLabel, q as SidebarItemIndicator, r as PanelActivity, rt as SidebarItemSubtitle, s as PanelHeaderContentProps, st as Badge, t as PanelActions, tt as SidebarItemStatus, u as PanelHeaderProps, ut as SidebarBodyProps, v as PanelStatusProps, vt as SidebarHeaderTitleProps, w as PanelEdge, wt as ButtonProps, x as Panel, xt as SidebarRoot, y as PanelTitle, yt as SidebarLiveActivity, z as SidebarItemChannelIcon } from "./panel-header-Bk1kF2oU.mjs";
import { cn } from "./cn.mjs";
import { Dialog as Dialog$1 } from "@base-ui/react/dialog";
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/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-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/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/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, ...props }: ContextMenuFooterProps): import("react").JSX.Element;
type ContextMenuSubmenuTriggerProps = StyledProps<ContextMenu$1.SubmenuTrigger.Props>;
declare function ContextMenuSubmenuTrigger({ className, ...props }: ContextMenuSubmenuTriggerProps): import("react").JSX.Element;
type ContextMenuLabelProps = StyledProps<ComponentPropsWithRef<"div">>;
declare function ContextMenuLabel({ className, ...props }: ContextMenuLabelProps): import("react").JSX.Element;
type ContextMenuShortcutProps = KbdProps;
declare function ContextMenuShortcut({ className, ...props }: ContextMenuShortcutProps): import("react").JSX.Element;
type ContextMenuSeparatorProps = StyledProps<ContextMenu$1.Separator.Props>;
declare function ContextMenuSeparator({ className, ...props }: ContextMenuSeparatorProps): import("react").JSX.Element;
type ContextMenuRadioGroupProps = StyledProps<ContextMenu$1.RadioGroup.Props>;
declare function ContextMenuRadioGroup({ ...props }: ContextMenuRadioGroupProps): import("react").JSX.Element;
type ContextMenuRadioItemProps = StyledProps<ContextMenu$1.RadioItem.Props>;
declare function ContextMenuRadioItem({ className, children, ...props }: ContextMenuRadioItemProps): import("react").JSX.Element;
type ContextMenuRadioItemIndicatorProps = StyledProps<ContextMenu$1.RadioItemIndicator.Props>;
declare function ContextMenuRadioItemIndicator({ className, ...props }: ContextMenuRadioItemIndicatorProps): import("react").JSX.Element;
type ContextMenuCheckboxItemProps = StyledProps<ContextMenu$1.CheckboxItem.Props>;
declare function ContextMenuCheckboxItem({ className, children, ...props }: ContextMenuCheckboxItemProps): import("react").JSX.Element;
type ContextMenuCheckboxItemIndicatorProps = StyledProps<ContextMenu$1.CheckboxItemIndicator.Props>;
declare function ContextMenuCheckboxItemIndicator({ className, ...props }: ContextMenuCheckboxItemIndicatorProps): import("react").JSX.Element;
//#endregion
//#region src/components/dropdown-menu/dropdown-menu.d.ts
type DropdownMenuProps = Menu.Root.Props;
declare function DropdownMenu(props: DropdownMenuProps): import("react").JSX.Element;
type DropdownMenuSubmenuProps = Menu.SubmenuRoot.Props;
declare function DropdownMenuSubmenu(props: DropdownMenuSubmenuProps): import("react").JSX.Element;
type DropdownMenuTriggerProps = StyledProps<Menu.Trigger.Props>;
declare function DropdownMenuTrigger({ className, render, ...props }: DropdownMenuTriggerProps): import("react").JSX.Element;
type DropdownMenuPortalProps = Menu.Portal.Props;
declare function DropdownMenuPortal(props: DropdownMenuPortalProps): import("react").JSX.Element;
type DropdownMenuPopupProps = ComponentPropsWithRef<"div">;
declare function DropdownMenuPopup({ className, ...props }: DropdownMenuPopupProps): import("react").JSX.Element;
type DropdownMenuContentProps = StyledProps<Menu.Popup.Props> & Pick<Menu.Positioner.Props, "align" | "alignOffset" | "anchor" | "arrowPadding" | "collisionAvoidance" | "collisionBoundary" | "collisionPadding" | "disableAnchorTracking" | "positionMethod" | "side" | "sideOffset" | "sticky"> & {
  portalProps?: DropdownMenuPortalProps;
};
declare function DropdownMenuContent({ align, alignOffset, anchor, arrowPadding, collisionAvoidance, collisionBoundary, collisionPadding, disableAnchorTracking, positionMethod, side, sideOffset, sticky, portalProps, className, ...props }: DropdownMenuContentProps): import("react").JSX.Element;
type DropdownMenuItemProps = StyledProps<Menu.Item.Props>;
declare function DropdownMenuItem({ className, ...props }: DropdownMenuItemProps): import("react").JSX.Element;
type DropdownMenuItemLabelProps = StyledProps<ComponentPropsWithRef<"span">>;
declare function DropdownMenuItemLabel({ className, ...props }: DropdownMenuItemLabelProps): import("react").JSX.Element;
type DropdownMenuFooterProps = StyledProps<ComponentPropsWithRef<"div">>;
declare function DropdownMenuFooter({ className, ...props }: DropdownMenuFooterProps): import("react").JSX.Element;
type DropdownMenuSubmenuTriggerProps = StyledProps<Menu.SubmenuTrigger.Props>;
declare function DropdownMenuSubmenuTrigger({ className, ...props }: DropdownMenuSubmenuTriggerProps): import("react").JSX.Element;
type DropdownMenuLabelProps = StyledProps<ComponentPropsWithRef<"div">>;
declare function DropdownMenuLabel({ className, ...props }: DropdownMenuLabelProps): import("react").JSX.Element;
type DropdownMenuShortcutProps = KbdProps;
declare function DropdownMenuShortcut({ className, ...props }: DropdownMenuShortcutProps): import("react").JSX.Element;
type DropdownMenuItemCountProps = BadgeProps;
declare function DropdownMenuItemCount({ className, ...props }: DropdownMenuItemCountProps): import("react").JSX.Element;
type DropdownMenuSeparatorProps = StyledProps<Menu.Separator.Props>;
declare function DropdownMenuSeparator({ className, ...props }: DropdownMenuSeparatorProps): import("react").JSX.Element;
type DropdownMenuRadioGroupProps = StyledProps<Menu.RadioGroup.Props>;
declare function DropdownMenuRadioGroup({ ...props }: DropdownMenuRadioGroupProps): import("react").JSX.Element;
type DropdownMenuRadioItemProps = StyledProps<Menu.RadioItem.Props>;
declare function DropdownMenuRadioItem({ className, children, ...props }: DropdownMenuRadioItemProps): import("react").JSX.Element;
type DropdownMenuRadioItemIndicatorProps = StyledProps<Menu.RadioItemIndicator.Props>;
declare function DropdownMenuRadioItemIndicator({ className, ...props }: DropdownMenuRadioItemIndicatorProps): import("react").JSX.Element;
type DropdownMenuCheckboxItemProps = StyledProps<Menu.CheckboxItem.Props>;
declare function DropdownMenuCheckboxItem({ className, children, ...props }: DropdownMenuCheckboxItemProps): import("react").JSX.Element;
type DropdownMenuCheckboxItemIndicatorProps = StyledProps<Menu.CheckboxItemIndicator.Props>;
declare function DropdownMenuCheckboxItemIndicator({ className, ...props }: DropdownMenuCheckboxItemIndicatorProps): import("react").JSX.Element;
//#endregion
//#region src/components/lightbox/lightbox.d.ts
type LightboxProps<Payload = unknown> = Omit<Dialog$1.Root.Props<Payload>, "actionsRef" | "children" | "handle"> & {
  children?: ReactNode;
  closeOnModW?: boolean;
};
declare function Lightbox<Payload = unknown>({ closeOnModW, defaultOpen, modal, onOpenChange, open, children, ...props }: LightboxProps<Payload>): import("react").JSX.Element;
type LightboxTriggerProps = Dialog$1.Trigger.Props;
declare function LightboxTrigger(props: LightboxTriggerProps): import("react").JSX.Element;
type LightboxPortalProps = Dialog$1.Portal.Props;
declare function LightboxPortal(props: LightboxPortalProps): import("react").JSX.Element;
type LightboxContentProps = StyledProps<Dialog$1.Popup.Props>;
declare function LightboxContent({ className, initialFocus, finalFocus, ...props }: LightboxContentProps): import("react").JSX.Element;
type LightboxHeaderProps = useRender.ComponentProps<"div">;
declare function LightboxHeader({ render, className, ...props }: LightboxHeaderProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type LightboxToolbarProps = useRender.ComponentProps<"div">;
declare function LightboxToolbar({ render, className, ...props }: LightboxToolbarProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type LightboxHeaderMetaProps = useRender.ComponentProps<"div">;
declare function LightboxHeaderMeta({ render, className, ...props }: LightboxHeaderMetaProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type LightboxHeaderLabelProps = useRender.ComponentProps<"span">;
declare function LightboxHeaderLabel({ render, className, ...props }: LightboxHeaderLabelProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type LightboxTitleProps = useRender.ComponentProps<"div">;
declare function LightboxTitle({ render, className, ...props }: LightboxTitleProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type LightboxActionsProps = useRender.ComponentProps<"div">;
declare function LightboxActions({ render, className, ...props }: LightboxActionsProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type LightboxStageProps = useRender.ComponentProps<"div">;
declare function LightboxStage({ render, className, ...props }: LightboxStageProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type LightboxMediaProps = useRender.ComponentProps<"div">;
declare function LightboxMedia({ render, className, ...props }: LightboxMediaProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type LightboxNavigationButtonProps = Omit<ButtonProps, "disabled" | "loading" | "size" | "variant"> & {
  direction: "next" | "previous";
  disabled?: boolean;
};
declare function LightboxNavigationButton({ className, direction, disabled, onClick, type, ...props }: LightboxNavigationButtonProps): import("react").JSX.Element;
type LightboxInfoDockProps = useRender.ComponentProps<"div">;
declare function LightboxInfoDock({ render, className, ...props }: LightboxInfoDockProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type LightboxInfoBarProps = useRender.ComponentProps<"div">;
declare function LightboxInfoBar({ render, className, ...props }: LightboxInfoBarProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type LightboxInfoTitleProps = useRender.ComponentProps<"div">;
declare function LightboxInfoTitle({ render, className, ...props }: LightboxInfoTitleProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type LightboxInfoActionsProps = useRender.ComponentProps<"div">;
declare function LightboxInfoActions({ render, className, ...props }: LightboxInfoActionsProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type LightboxThumbnailStripProps = useRender.ComponentProps<"div">;
declare function LightboxThumbnailStrip({ render, className, ...props }: LightboxThumbnailStripProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type LightboxThumbnailProps = useRender.ComponentProps<"button"> & {
  active?: boolean;
};
declare function LightboxThumbnail({ active, className, render, type, children, ...props }: LightboxThumbnailProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type LightboxCloseProps = StyledProps<Dialog$1.Close.Props>;
declare function LightboxClose({ className, render, ...props }: LightboxCloseProps): import("react").JSX.Element;
//#endregion
//#region src/components/logo/raft-logo.d.ts
type RaftLogoProps = ComponentPropsWithoutRef<"svg">;
declare function RaftLogo(props: RaftLogoProps): import("react").JSX.Element;
type RaftWordmarkProps = ComponentPropsWithoutRef<"svg">;
declare function RaftWordmark(props: RaftWordmarkProps): import("react").JSX.Element;
type RaftLogoLockupProps = ComponentPropsWithoutRef<"svg">;
declare function RaftLogoLockup(props: RaftLogoLockupProps): import("react").JSX.Element;
//#endregion
//#region src/components/mobile-nav/mobile-nav.d.ts
type MobileNavRootProps = useRender.ComponentProps<"nav">;
declare function MobileNavRoot({ className, render, ...props }: MobileNavRootProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MobileNavItemProps = useRender.ComponentProps<"button"> & {
  nativeButton?: boolean;
  selected?: boolean;
};
declare function MobileNavItem({ nativeButton, selected, className, render, ...props }: MobileNavItemProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MobileNavLabelProps = useRender.ComponentProps<"span">;
declare function MobileNavLabel({ className, render, ...props }: MobileNavLabelProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/tooltip/tooltip.d.ts
type TooltipProviderProps = Tooltip$1.Provider.Props;
declare function TooltipProvider({ delay, ...props }: TooltipProviderProps): import("react").JSX.Element;
type TooltipProps = Tooltip$1.Root.Props;
declare function Tooltip(props: TooltipProps): import("react").JSX.Element;
type TooltipTriggerProps = StyledProps<Tooltip$1.Trigger.Props>;
declare function TooltipTrigger({ className, ...props }: TooltipTriggerProps): import("react").JSX.Element;
type TooltipPortalProps = Tooltip$1.Portal.Props;
declare function TooltipPortal(props: TooltipPortalProps): import("react").JSX.Element;
type TooltipContentProps = StyledProps<Tooltip$1.Popup.Props> & Pick<Tooltip$1.Positioner.Props, "align" | "alignOffset" | "anchor" | "arrowPadding" | "collisionAvoidance" | "collisionBoundary" | "collisionPadding" | "disableAnchorTracking" | "positionMethod" | "side" | "sideOffset" | "sticky"> & {
  container?: TooltipPortalProps["container"];
  portalProps?: TooltipPortalProps;
};
declare function TooltipContent({ align, alignOffset, anchor, arrowPadding, collisionAvoidance, collisionBoundary, collisionPadding, disableAnchorTracking, positionMethod, side, sideOffset, sticky, container, portalProps, className, children, ...props }: TooltipContentProps): import("react").JSX.Element;
//#endregion
//#region src/components/popover/popover.d.ts
type PopoverProps = Popover$1.Root.Props;
declare function Popover(props: PopoverProps): import("react").JSX.Element;
type PopoverTriggerProps = StyledProps<Popover$1.Trigger.Props>;
declare function PopoverTrigger({ className, ...props }: PopoverTriggerProps): import("react").JSX.Element;
type PopoverPortalProps = Popover$1.Portal.Props;
declare function PopoverPortal(props: PopoverPortalProps): import("react").JSX.Element;
type PopoverPopupProps = ComponentPropsWithRef<"div">;
declare function PopoverPopup({ className, ...props }: PopoverPopupProps): import("react").JSX.Element;
type PopoverContentProps = StyledProps<Popover$1.Popup.Props> & Pick<Popover$1.Positioner.Props, "align" | "alignOffset" | "anchor" | "arrowPadding" | "collisionAvoidance" | "collisionBoundary" | "collisionPadding" | "disableAnchorTracking" | "positionMethod" | "side" | "sideOffset" | "sticky"> & {
  container?: PopoverPortalProps["container"];
  portalProps?: PopoverPortalProps;
};
declare function PopoverContent({ align, alignOffset, anchor, arrowPadding, collisionAvoidance, collisionBoundary, collisionPadding, disableAnchorTracking, positionMethod, side, sideOffset, sticky, container, portalProps, className, ...props }: PopoverContentProps): import("react").JSX.Element;
type PopoverViewportProps = StyledProps<Popover$1.Viewport.Props>;
declare function PopoverViewport({ className, ...props }: PopoverViewportProps): import("react").JSX.Element;
type PopoverHeaderProps = ComponentPropsWithRef<"div">;
declare function PopoverHeader({ className, ...props }: PopoverHeaderProps): import("react").JSX.Element;
type PopoverSeparatorProps = StyledProps<ComponentPropsWithRef<"div">>;
declare function PopoverSeparator({ className, ...props }: PopoverSeparatorProps): import("react").JSX.Element;
type PopoverTitleProps = StyledProps<Popover$1.Title.Props>;
declare function PopoverTitle({ className, ...props }: PopoverTitleProps): import("react").JSX.Element;
type PopoverDescriptionProps = StyledProps<Popover$1.Description.Props>;
declare function PopoverDescription({ className, ...props }: PopoverDescriptionProps): import("react").JSX.Element;
type PopoverCloseProps = StyledProps<Popover$1.Close.Props>;
declare function PopoverClose({ className, ...props }: PopoverCloseProps): import("react").JSX.Element;
type PopoverArrowProps = StyledProps<Popover$1.Arrow.Props>;
declare function PopoverArrow({ className, ...props }: PopoverArrowProps): import("react").JSX.Element;
type PopoverBackdropProps = StyledProps<Popover$1.Backdrop.Props>;
declare function PopoverBackdrop({ className, ...props }: PopoverBackdropProps): import("react").JSX.Element;
//#endregion
//#region src/components/preview-card/preview-card.d.ts
type PreviewCardProps = PreviewCard$1.Root.Props;
de