@gomeniucivan/ui 1.0.32 → 1.0.35

package/dist/index.d.mts

@@ -0,0 +1,4052 @@
+import * as react from 'react';
+import react__default, { AnchorHTMLAttributes, HTMLAttributes, FC, Ref, ElementType, ReactNode, CSSProperties, DOMAttributes, Key, ReactElement, ComponentPropsWithRef, RefAttributes, Context, MouseEvent, ComponentProps, ComponentType, KeyboardEvent } from 'react';
+import { LucideProps, LucideIcon } from 'lucide-react';
+import { TooltipPopupProps, TooltipPortalProps as TooltipPortalProps$1, TooltipPositionerProps as TooltipPositionerProps$1, Tooltip as Tooltip$1, TooltipTriggerProps } from '@base-ui/react/tooltip';
+import { Placement as Placement$1 } from '@floating-ui/react';
+import * as _base_ui_react_menu from '@base-ui/react/menu';
+import { MenuRootProps, MenuPopupProps, MenuPortalProps, MenuPositionerProps, MenuTriggerProps, Menu as Menu$1 } from '@base-ui/react/menu';
+import { MenuProps as MenuProps$1, MenuRef, AlertProps as AlertProps$1, AutoCompleteProps as AutoCompleteProps$1, AvatarProps as AvatarProps$1, DrawerProps as DrawerProps$1, ButtonProps as ButtonProps$1, CollapseProps as CollapseProps$1, DatePickerProps as DatePickerProps$1, InputProps as InputProps$1, InputRef, InputNumberProps as InputNumberProps$1, TagProps as TagProps$1, FormProps as FormProps$1, FormInstance, Form as Form$1, ModalProps as ModalProps$1, ImageProps as ImageProps$2, SelectProps as SelectProps$1, TabsProps as TabsProps$1, AnchorProps, SegmentedProps as SegmentedProps$1, RefSelectProps, SliderSingleProps } from 'antd';
+export { FormInstance } from 'antd';
+import { MenuItemType as MenuItemType$1, SubMenuType as SubMenuType$1, MenuItemGroupType as MenuItemGroupType$1, MenuDividerType as MenuDividerType$1, MenuInfo } from 'rc-menu/es/interface';
+export { MenuInfo } from 'rc-menu/es/interface';
+import { AlertRef } from 'antd/lib/alert/Alert';
+import { FileDiffOptions } from '@pierre/diffs';
+import { ItemType as ItemType$1 } from 'rc-collapse/es/interface';
+import * as motion_react from 'motion/react';
+import { HTMLMotionProps, Transition, TargetAndTransition } from 'motion/react';
+import * as m from 'motion/react-m';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { Size, NumberSize } from 're-resizable';
+import { Props as Props$1 } from 'react-rnd';
+import { DropdownProps as DropdownProps$1 } from 'antd/es';
+import { OTPProps, OTPRef } from 'antd/es/input/OTP';
+import { PasswordProps } from 'antd/es/input/Password';
+import { TextAreaProps as TextAreaProps$2, TextAreaRef } from 'antd/es/input/TextArea';
+import { InputNumberRef } from 'rc-input-number';
+import * as _base_ui_react_autocomplete from '@base-ui/react/autocomplete';
+import { Autocomplete, AutocompleteRootChangeEventDetails, AutocompleteRootProps } from '@base-ui/react/autocomplete';
+import * as _base_ui_react_popover from '@base-ui/react/popover';
+import { PopoverBackdropProps as PopoverBackdropProps$1, PopoverPopupProps as PopoverPopupProps$1, PopoverPortalProps as PopoverPortalProps$1, PopoverPositionerProps as PopoverPositionerProps$1, Popover as Popover$1, PopoverTriggerProps } from '@base-ui/react/popover';
+import { FooterProps as FooterProps$1 } from 'rc-footer';
+import { FormItemProps as FormItemProps$1 } from 'antd/es/form/FormItem';
+import { BuiltinTheme } from 'shiki';
+import { PreviewConfig } from 'antd/es/image';
+import { GroupPreviewConfig } from 'antd/es/image/PreviewGroup';
+import * as node_modules__base_ui_react_esm_separator_Separator from 'node_modules/@base-ui/react/esm/separator/Separator';
+import * as _base_ui_react_select from '@base-ui/react/select';
+import { Select as Select$1 } from '@base-ui/react/select';
+import { Switch } from '@base-ui/react/switch';
+import { Components, Options } from 'react-markdown';
+import { Pluggable } from 'unified';
+import { MermaidConfig } from 'mermaid';
+import { Node } from 'unist';
+import { Root } from 'hast';
+import { ScrollArea as ScrollArea$1 } from '@base-ui/react/scroll-area';
+import { GetCustomStylish, GetCustomToken, ThemeProviderProps as ThemeProviderProps$1, CustomStylishParams, CustomTokenParams, ThemeMode } from 'antd-style';
+import { AliasToken } from 'antd/es/theme/interface';
+import { Toast } from '@base-ui/react/toast';
+export { ErrorBoundary, ErrorBoundaryProps } from 'react-error-boundary';
+
+interface LobeCustomStylish {
+    active: string;
+    blur: string;
+    blurStrong: string;
+    bottomScrollbar: string;
+    disabled: string;
+    gradientAnimation: string;
+    noScrollbar: string;
+    resetLinkColor: string;
+    shadow: string;
+    variantBorderless: string;
+    variantBorderlessDanger: string;
+    variantBorderlessWithoutHover: string;
+    variantFilled: string;
+    variantFilledDanger: string;
+    variantFilledWithoutHover: string;
+    variantOutlined: string;
+    variantOutlinedDanger: string;
+    variantOutlinedWithoutHover: string;
+}
+
+declare const PresetColors: readonly ["red", "volcano", "orange", "gold", "yellow", "lime", "green", "cyan", "blue", "geekblue", "purple", "magenta", "gray"];
+declare const PresetSystemColors: readonly ["Error", "Warning", "Success", "Info"];
+type PresetColorKey = (typeof PresetColors)[number];
+type PresetSystemColorKey = (typeof PresetSystemColors)[number];
+type PresetColorType = Record<PresetColorKey, string>;
+type PresetSystemColorType = Record<PresetSystemColorKey, string>;
+type ColorPaletteKeyIndex = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11;
+type ColorTokenKey = 'Fill' | 'FillSecondary' | 'FillTertiary' | 'FillQuaternary' | 'Bg' | 'BgHover' | 'Border' | 'BorderSecondary' | 'BorderHover' | 'Hover' | '' | 'Active' | 'TextHover' | 'Text' | 'TextActive';
+type SystemColorTokenKey = 'Fill' | 'FillSecondary' | 'FillTertiary' | 'FillQuaternary';
+type ColorToken = {
+    [key in `${keyof PresetColorType}${ColorTokenKey}`]: string;
+};
+type SystemColorToken = {
+    [key in `color${keyof PresetSystemColorType}${SystemColorTokenKey}`]: string;
+};
+type ColorPalettes = {
+    [key in `${keyof PresetColorType}${ColorPaletteKeyIndex}`]: string;
+};
+type ColorPalettesAlpha = {
+    [key in `${keyof PresetColorType}${ColorPaletteKeyIndex}A`]: string;
+};
+interface LobeCustomToken extends ColorPalettes, ColorPalettesAlpha, ColorToken, SystemColorToken {
+    colorBgContainerSecondary: string;
+}
+
+/**
+ * Common trigger type for components that support hover/click interactions
+ */
+type Trigger = 'hover' | 'click' | 'both' | ('hover' | 'click')[];
+
+type DivProps$1 = HTMLAttributes<HTMLDivElement>;
+type VideoProps$2 = HTMLAttributes<HTMLVideoElement>;
+type SvgProps = HTMLAttributes<SVGSVGElement>;
+type ImgProps = HTMLAttributes<HTMLImageElement>;
+type AProps = AnchorHTMLAttributes<HTMLAnchorElement>;
+type TextAreaProps$1 = HTMLAttributes<HTMLTextAreaElement>;
+type SpanProps = HTMLAttributes<HTMLSpanElement>;
+
+declare const A: FC<AProps & {
+    ref?: Ref<HTMLAnchorElement>;
+}>;
+
+type ContentPosition = 'center' | 'end' | 'flex-end' | 'flex-start' | 'start' | 'stretch' | 'baseline';
+type FlexDirection = 'vertical' | 'vertical-reverse' | 'horizontal' | 'horizontal-reverse';
+type DivProps = DOMAttributes<HTMLDivElement> & HTMLAttributes<HTMLDivElement>;
+type CommonSpaceNumber = 2 | 4 | 8 | 12 | 16 | 24;
+/**
+ * Flexbox 布局组件的接口
+ */
+interface IFlexbox {
+    /**
+     * 交叉轴对齐方式
+     * @default "stretch"
+     */
+    align?: ContentPosition;
+    /**
+     * 允许在 flex 布局中正常收缩（通过将根节点的 min-width 设为 0 实现）
+     *
+     * 在 Flex 容器（或作为 flex item）中，启用该选项可避免内容导致的溢出，
+     * 让元素可以正常 shrink（常见于文本省略、滚动容器等场景）。
+     * @default false
+     */
+    allowShrink?: boolean;
+    /**
+     * 渲染的 HTML 元素类型
+     * @default "div"
+     */
+    as?: ElementType;
+    /**
+     * 子元素
+     */
+    children?: ReactNode;
+    /**
+     * 自定义类名
+     */
+    className?: string;
+    /**
+     * 主轴方向
+     * @default "horizontal"
+     */
+    direction?: FlexDirection;
+    /**
+     * 内容分布
+     */
+    distribution?: CSSProperties['justifyContent'];
+    /**
+     * flex 值
+     * @default "0 1 auto"
+     */
+    flex?: number | string;
+    /**
+     * 主轴方向上的间距
+     * @default 0
+     */
+    gap?: CommonSpaceNumber | number | string;
+    /**
+     * 高度
+     * @default "auto"
+     */
+    height?: number | string;
+    /**
+     * 是否横向
+     * @default false
+     */
+    horizontal?: boolean;
+    /**
+     * 主轴对齐方式
+     */
+    justify?: CSSProperties['justifyContent'];
+    /**
+     * 内边距
+     * @default 0
+     */
+    padding?: string | number | CommonSpaceNumber;
+    /**
+     * 块内边距
+     */
+    paddingBlock?: string | number;
+    /**
+     * 内联内边距
+     */
+    paddingInline?: string | number;
+    /**
+     * 类名前缀
+     */
+    prefixCls?: string;
+    /**
+     * ref 引用
+     */
+    ref?: Ref<HTMLElement>;
+    /**
+     * 自定义样式
+     */
+    style?: CSSProperties;
+    /**
+     * 是否显示
+     * @default true
+     */
+    visible?: boolean;
+    /**
+     * 宽度
+     * @default "auto"
+     */
+    width?: number | string;
+    /**
+     * 换行方式
+     */
+    wrap?: CSSProperties['flexWrap'];
+}
+interface FlexBasicProps extends IFlexbox, DivProps {
+}
+type FlexboxProps = FlexBasicProps;
+type CenterProps = Omit<FlexBasicProps, 'distribution' | 'direction' | 'align'>;
+
+declare const Center: FC<CenterProps>;
+
+declare const _default$9: react.NamedExoticComponent<FlexBasicProps>;
+
+interface BlockProps extends FlexboxProps {
+    clickable?: boolean;
+    glass?: boolean;
+    ref?: Ref<HTMLDivElement>;
+    shadow?: boolean;
+    variant?: 'filled' | 'outlined' | 'borderless';
+}
+
+declare const Block: FC<BlockProps>;
+
+interface AccordionItemProps extends Pick<BlockProps, 'padding' | 'paddingBlock' | 'paddingInline' | 'variant' | 'ref'> {
+    /**
+     * Action component that appears on hover
+     */
+    action?: ReactNode;
+    /**
+     * Whether to allow expanding (hide indicator when false)
+     * @default true
+     */
+    allowExpand?: boolean;
+    /**
+     * Content of the accordion item
+     */
+    children?: ReactNode;
+    /**
+     * Custom classNames for child elements
+     */
+    classNames?: {
+        action?: string;
+        base?: string;
+        content?: string;
+        header?: string;
+        indicator?: string;
+        title?: string;
+    };
+    /**
+     * Default expanded state (uncontrolled)
+     */
+    defaultExpand?: boolean;
+    /**
+     * Whether the item is disabled
+     */
+    disabled?: boolean;
+    /**
+     * Controlled expanded state
+     */
+    expand?: boolean;
+    headerWrapper?: (header: ReactNode) => ReactNode;
+    /**
+     * Whether to hide the chevron indicator
+     * @default false
+     */
+    hideIndicator?: boolean;
+    /**
+     * Custom indicator component or function
+     */
+    indicator?: ReactNode | ((props: {
+        isDisabled?: boolean;
+        isOpen: boolean;
+    }) => ReactNode);
+    /**
+     * Indicator placement
+     * @default 'start'
+     */
+    indicatorPlacement?: 'end' | 'start';
+    /**
+     * Unique identifier for the item (use as React key)
+     */
+    itemKey: Key;
+    /**
+     * Callback when expanded state changes
+     */
+    onExpandChange?: (expanded: boolean) => void;
+    /**
+     * Custom styles for child elements
+     */
+    styles?: {
+        action?: CSSProperties;
+        base?: CSSProperties;
+        content?: CSSProperties;
+        header?: CSSProperties;
+        indicator?: CSSProperties;
+        title?: CSSProperties;
+    };
+    /**
+     * Title of the accordion item
+     */
+    title: ReactNode;
+}
+interface AccordionProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'>, Pick<BlockProps, 'variant' | 'ref'> {
+    /**
+     * Whether only one item can be expanded at a time
+     * @default false
+     */
+    accordion?: boolean;
+    /**
+     * Accordion items
+     */
+    children?: ReactNode;
+    /**
+     * Custom classNames for child elements
+     */
+    classNames?: {
+        base?: string;
+    };
+    /**
+     * Default expanded keys (uncontrolled)
+     */
+    defaultExpandedKeys?: Key[];
+    /**
+     * Disable animation
+     * @default false
+     */
+    disableAnimation?: boolean;
+    /**
+     * Controlled expanded keys
+     */
+    expandedKeys?: Key[];
+    /**
+     * Gap between accordion items
+     */
+    gap?: number;
+    /**
+     * Whether to hide the chevron indicator for all items
+     * @default false
+     */
+    hideIndicator?: boolean;
+    /**
+     * Indicator placement for all items
+     * @default 'start'
+     */
+    indicatorPlacement?: 'end' | 'start';
+    /**
+     * Keep content mounted when collapsed
+     * @default true
+     */
+    keepContentMounted?: boolean;
+    /**
+     * Motion props for motion animation
+     */
+    motionProps?: any;
+    /**
+     * Callback when expanded keys change
+     */
+    onExpandedChange?: (keys: Key[]) => void;
+    /**
+     * Whether to show dividers between items
+     * @default false
+     */
+    showDivider?: boolean;
+    /**
+     * Custom styles for child elements
+     */
+    styles?: {
+        base?: CSSProperties;
+    };
+}
+
+declare const Accordion: react.NamedExoticComponent<AccordionProps>;
+
+declare const AccordionItem: react.NamedExoticComponent<AccordionItemProps>;
+
+interface IconSizeConfig extends Pick<LucideProps, 'strokeWidth' | 'absoluteStrokeWidth'> {
+    size?: number | string;
+}
+type IconSizeType = 'large' | 'middle' | 'small';
+type IconSize = number | IconSizeType | IconSizeConfig;
+type LucideIconProps = Pick<LucideProps, 'fill' | 'fillRule' | 'fillOpacity' | 'color' | 'focusable'>;
+interface IconProps$1 extends Omit<SpanProps, 'children'>, LucideIconProps {
+    icon: LucideIcon | FC<any> | ReactNode;
+    ref?: Ref<SVGSVGElement>;
+    size?: IconSize;
+    spin?: boolean;
+}
+
+type IconContentConfig = Omit<IconProps$1, 'icon' | 'ref'>;
+declare const IconProvider: react.NamedExoticComponent<{
+    children: ReactNode;
+    config?: IconContentConfig;
+}>;
+
+declare const Icon: react.NamedExoticComponent<IconProps$1>;
+
+declare const KeyMapEnum: {
+    readonly Alt: "alt";
+    readonly Backquote: "backquote";
+    readonly Backslash: "backslash";
+    readonly Backspace: "backspace";
+    readonly BracketLeft: "bracketleft";
+    readonly BracketRight: "bracketright";
+    readonly Comma: "comma";
+    readonly CommandOrControl: "commandorcontrol";
+    readonly Control: "control";
+    readonly Ctrl: "ctrl";
+    readonly Down: "down";
+    readonly Enter: "enter";
+    readonly Equal: "equal";
+    readonly Esc: "esc";
+    readonly Left: "left";
+    readonly LeftClick: "left-click";
+    readonly LeftDoubleClick: "left-double-click";
+    readonly Meta: "meta";
+    readonly MiddleClick: "middle-click";
+    readonly Minus: "minus";
+    readonly Mod: "mod";
+    readonly Period: "period";
+    readonly Plus: "equal";
+    readonly QuestionMark: "slash";
+    readonly Quote: "quote";
+    readonly Right: "right";
+    readonly RightClick: "right-click";
+    readonly RightDoubleClick: "right-double-click";
+    readonly Semicolon: "semicolon";
+    readonly Shift: "shift";
+    readonly Slash: "slash";
+    readonly Space: "space";
+    readonly Tab: "tab";
+    readonly Up: "up";
+};
+
+interface HotkeyProps extends Omit<FlexboxProps, 'children'> {
+    classNames?: {
+        kbdClassName?: string;
+    };
+    compact?: boolean;
+    inverseTheme?: boolean;
+    isApple?: boolean;
+    keys: string;
+    styles?: {
+        kbdStyle?: CSSProperties;
+    };
+    variant?: 'filled' | 'outlined' | 'borderless';
+}
+
+declare const Hotkey: react.NamedExoticComponent<HotkeyProps>;
+
+declare const combineKeys: (keys: string[]) => string;
+
+/**
+ * Base UI uses a small set of string literal unions for alignment and side.
+ * We re-declare them here to avoid importing internal/non-exported Base UI paths.
+ */
+type Side = 'top' | 'bottom' | 'left' | 'right' | 'inline-end' | 'inline-start';
+type Align = 'start' | 'center' | 'end';
+type PlacementConfig = {
+    align: Align;
+    side: Side;
+};
+/**
+ * All supported placement values
+ * - Unified placement names for Tooltip, Popover, and DropdownMenu
+ * - Ant Design style: topLeft, topCenter, topRight, etc.
+ * - Additional aliases: top (same as topCenter), bottom (same as bottomCenter)
+ */
+type Placement = 'top' | 'topLeft' | 'topCenter' | 'topRight' | 'bottom' | 'bottomLeft' | 'bottomCenter' | 'bottomRight' | 'left' | 'leftTop' | 'leftBottom' | 'right' | 'rightTop' | 'rightBottom';
+/**
+ * Map of placement values to Base UI placement config
+ * Used by Popover and DropdownMenu components
+ */
+declare const placementMap: Record<Placement, PlacementConfig>;
+/**
+ * Convert unified Placement to Floating UI placement format
+ * Used by Tooltip component which uses @floating-ui/react
+ *
+ * @param placement - Unified placement value
+ * @returns Floating UI placement (e.g., 'top-start', 'bottom-end')
+ */
+declare const toFloatingUIPlacement: (placement?: Placement) => Placement$1;
+
+type TooltipPlacement = Placement;
+/**
+ * Base UI Positioner props that can be passed through
+ */
+type TooltipPositionerProps = Omit<TooltipPositionerProps$1, 'className' | 'style' | 'children'>;
+/**
+ * Base UI Trigger props that can be passed through
+ */
+type TooltipTriggerComponentProps = Omit<TooltipTriggerProps, 'className' | 'style' | 'children' | 'render' | 'handle' | 'payload'>;
+/**
+ * Base UI Popup props that can be passed through
+ */
+type TooltipPopupComponentProps = Omit<TooltipPopupProps, 'className' | 'style' | 'children'>;
+/**
+ * Base UI Portal props that can be passed through
+ */
+type TooltipPortalProps = Omit<TooltipPortalProps$1, 'children' | 'container'>;
+interface TooltipProps {
+    /**
+     * Whether the tooltip has an arrow pointer.
+     * @default false
+     */
+    arrow?: boolean;
+    /**
+     * Trigger element. Prefer a single React element.
+     */
+    children: ReactElement | ReactNode;
+    /**
+     * Custom className for the tooltip floating root.
+     */
+    className?: string;
+    /**
+     * Compatible with Ant Design `classNames` shape (subset).
+     */
+    classNames?: {
+        arrow?: string;
+        container?: string;
+        content?: string;
+        root?: string;
+    };
+    /**
+     * Delay (in milliseconds) before closing the tooltip.
+     * Takes precedence over `mouseLeaveDelay`.
+     */
+    closeDelay?: number;
+    /**
+     * Uncontrolled initial open state.
+     */
+    defaultOpen?: boolean;
+    /**
+     * Disable tooltip behavior.
+     */
+    disabled?: boolean;
+    /**
+     * An Ant Design compatible escape hatch for portal container.
+     */
+    getPopupContainer?: (triggerNode: HTMLElement) => HTMLElement;
+    hotkey?: string;
+    hotkeyProps?: Omit<HotkeyProps, 'keys'>;
+    /**
+     * Delay (in seconds) before showing the tooltip on hover.
+     * Kept compatible with Ant Design `Tooltip`.
+     */
+    mouseEnterDelay?: number;
+    /**
+     * Delay (in seconds) before hiding the tooltip on hover out.
+     * Kept compatible with Ant Design `Tooltip`.
+     */
+    mouseLeaveDelay?: number;
+    /**
+     * Callback when open state changes.
+     */
+    onOpenChange?: (open: boolean) => void;
+    /**
+     * Controlled open state.
+     */
+    open?: boolean;
+    /**
+     * Delay (in milliseconds) before opening the tooltip.
+     * Takes precedence over `mouseEnterDelay`.
+     */
+    openDelay?: number;
+    /**
+     * Tooltip placement. Supports Floating UI placements and Ant Design legacy placements.
+     */
+    placement?: TooltipPlacement;
+    /**
+     * Base UI Popup 组件的 props
+     */
+    popupProps?: TooltipPopupComponentProps;
+    /**
+     * Base UI Portal 组件的 props
+     */
+    portalProps?: TooltipPortalProps;
+    /**
+     * Base UI Positioner 组件的 props
+     */
+    positionerProps?: TooltipPositionerProps;
+    ref?: ComponentPropsWithRef<typeof Tooltip$1.Trigger>['ref'];
+    /**
+     * When true, this tooltip will render independently even inside a TooltipGroup,
+     * ignoring the group singleton behavior.
+     */
+    standalone?: boolean;
+    /**
+     * Compatible with Ant Design `styles` shape (subset).
+     */
+    styles?: {
+        arrow?: CSSProperties;
+        /**
+         * Backwards-compatible alias for the floating root style.
+         */
+        container?: CSSProperties;
+        content?: CSSProperties;
+        root?: CSSProperties;
+    };
+    /**
+     * Tooltip content.
+     */
+    title: ReactNode;
+    /**
+     * Base UI Trigger 组件的 props
+     */
+    triggerProps?: TooltipTriggerComponentProps;
+    /**
+     * z-index for tooltip floating root.
+     */
+    zIndex?: number;
+}
+/**
+ * Props for `TooltipGroup`.
+ */
+interface TooltipGroupProps {
+    arrow?: boolean;
+    children: ReactNode;
+    className?: string;
+    classNames?: TooltipProps['classNames'];
+    closeDelay?: number;
+    /**
+     * Disable the "destroy on invalid trigger (display:none / disconnected)" guard for performance.
+     * @default false
+     */
+    disableDestroyOnInvalidTrigger?: boolean;
+    /**
+     * Disable the "hide when positioner falls back to (0,0)" visual guard for performance.
+     * @default false
+     */
+    disableZeroOriginGuard?: boolean;
+    disabled?: boolean;
+    getPopupContainer?: TooltipProps['getPopupContainer'];
+    hotkey?: string;
+    hotkeyProps?: Omit<HotkeyProps, 'keys'>;
+    layoutAnimation?: boolean;
+    mouseEnterDelay?: number;
+    mouseLeaveDelay?: number;
+    openDelay?: number;
+    placement?: TooltipPlacement;
+    popupProps?: TooltipPopupComponentProps;
+    portalProps?: TooltipPortalProps;
+    positionerProps?: TooltipPositionerProps;
+    styles?: TooltipProps['styles'];
+    triggerProps?: TooltipTriggerComponentProps;
+    zIndex?: number;
+}
+
+declare const Tooltip: FC<TooltipProps>;
+
+declare const TooltipGroup: FC<TooltipGroupProps>;
+
+interface ActionIconSizeConfig extends IconSizeConfig {
+    blockSize?: number | string;
+    borderRadius?: number | string;
+}
+type ActionIconSize = number | IconSizeType | ActionIconSizeConfig;
+interface ActionIconProps extends Partial<LucideIconProps>, Omit<CenterProps, 'title' | 'children'> {
+    active?: boolean;
+    danger?: boolean;
+    disabled?: boolean;
+    glass?: boolean;
+    icon?: IconProps$1['icon'] | ReactNode;
+    loading?: boolean;
+    ref?: Ref<HTMLDivElement>;
+    shadow?: boolean;
+    size?: ActionIconSize;
+    spin?: boolean;
+    title?: TooltipProps['title'];
+    tooltipProps?: Omit<TooltipProps, 'children' | 'title'>;
+    variant?: 'borderless' | 'filled' | 'outlined';
+}
+
+declare const ActionIcon: react.NamedExoticComponent<ActionIconProps>;
+
+/**
+ * Checkbox menu item shared by DropdownMenu / ContextMenu.
+ * This is intentionally aligned with Base UI's `Menu.CheckboxItem` API we use.
+ */
+interface MenuCheckboxItemType {
+    checked?: boolean;
+    closeOnClick?: boolean;
+    danger?: boolean;
+    defaultChecked?: boolean;
+    disabled?: boolean;
+    extra?: ReactNode;
+    icon?: IconProps$1['icon'];
+    key: Key;
+    label?: ReactNode;
+    onCheckedChange?: (checked: boolean) => void;
+    title?: ReactNode;
+    type: 'checkbox';
+}
+
+/**
+ * Switch menu item shared by DropdownMenu / ContextMenu.
+ * Similar to checkbox but renders as a toggle switch.
+ */
+interface MenuSwitchItemType {
+    checked?: boolean;
+    closeOnClick?: boolean;
+    danger?: boolean;
+    defaultChecked?: boolean;
+    disabled?: boolean;
+    extra?: ReactNode;
+    icon?: IconProps$1['icon'];
+    key: Key;
+    label?: ReactNode;
+    onCheckedChange?: (checked: boolean) => void;
+    title?: ReactNode;
+    type: 'switch';
+}
+
+interface MenuItemType extends MenuItemType$1 {
+    /**
+     * Whether to close the menu when this item is clicked.
+     * Set to `false` to keep the menu open (useful for items with Upload, file picker, etc.)
+     * @default true
+     */
+    closeOnClick?: boolean;
+    danger?: boolean;
+    icon?: IconProps$1['icon'];
+    loading?: boolean;
+    title?: string;
+}
+interface SubMenuType<T extends MenuItemType = MenuItemType> extends Omit<SubMenuType$1, 'children'> {
+    children: ItemType<T>[];
+    icon?: IconProps$1['icon'];
+}
+interface MenuItemGroupType<T extends MenuItemType = MenuItemType> extends Omit<MenuItemGroupType$1, 'children'> {
+    children?: ItemType<T>[];
+    key?: Key;
+}
+interface MenuDividerType extends MenuDividerType$1 {
+    dashed?: boolean;
+    key?: Key;
+}
+type ItemType<T extends MenuItemType = MenuItemType> = T | SubMenuType<T> | MenuItemGroupType<T> | MenuDividerType | null;
+type GenericItemType<T = unknown> = T extends infer U extends MenuItemType ? unknown extends U ? ItemType : ItemType<U> : ItemType;
+interface MenuProps<T = unknown> extends Omit<MenuProps$1, 'items'> {
+    compact?: boolean;
+    iconProps?: IconContentConfig;
+    items: GenericItemType<T>[];
+    ref?: Ref<MenuRef>;
+    shadow?: boolean;
+    variant?: 'filled' | 'outlined' | 'borderless';
+}
+
+/**
+ * Group type for Base UI driven menus (DropdownMenu / ContextMenu).
+ * Unlike MenuItemGroupType, this supports checkbox/switch items in children.
+ */
+interface BaseMenuItemGroupType {
+    children?: BaseMenuItemType[];
+    key?: Key;
+    label?: ReactNode;
+    type: 'group';
+}
+/**
+ * Submenu type for Base UI driven menus (DropdownMenu / ContextMenu).
+ * Unlike SubMenuType, this supports checkbox/switch items in children.
+ */
+interface BaseSubMenuType extends Omit<SubMenuType, 'children'> {
+    children?: BaseMenuItemType[];
+}
+/**
+ * Base item union for Base UI driven menus (DropdownMenu / ContextMenu).
+ *
+ * Note: This intentionally does NOT change `GenericItemType` itself,
+ * because `GenericItemType` maps to rc-menu/antd Menu item types.
+ */
+type BaseMenuItemType = MenuItemType | BaseSubMenuType | BaseMenuItemGroupType | MenuDividerType | MenuCheckboxItemType | MenuSwitchItemType | null;
+
+declare const Menu: react.NamedExoticComponent<MenuProps<unknown>>;
+
+type IconSpaceMode = 'global' | 'group';
+interface RenderOptions {
+    iconSpaceMode?: IconSpaceMode;
+    indicatorOnRight?: boolean;
+    reserveIconSpace?: boolean;
+}
+
+declare const renderDropdownMenuItems: (items: DropdownItem[], keyPath?: string[], options?: RenderOptions) => ReactNode[];
+
+type DropdownMenuPlacement = Placement;
+type DropdownMenuCheckboxItem = MenuCheckboxItemType;
+type DropdownItem = BaseMenuItemType;
+interface DropdownMenuProps<Payload = unknown> extends Omit<MenuRootProps<Payload>, 'children'> {
+    children: ReactNode;
+    /**
+     * 图标空间保留模式
+     * - 'global': 当任何一个选项有图标时，所有 item 都保留图标位
+     * - 'group': 只有当一个分组中存在图标时，该分组才保留图标位
+     * @default 'global'
+     */
+    iconSpaceMode?: IconSpaceMode;
+    items: DropdownItem[] | (() => DropdownItem[]);
+    nativeButton?: boolean;
+    placement?: DropdownMenuPlacement;
+    popupProps?: MenuPopupProps;
+    portalProps?: MenuPortalProps;
+    positionerProps?: MenuPositionerProps;
+    /**
+     * 触发方式
+     * @default 'click'
+     */
+    trigger?: Trigger;
+    triggerProps?: Omit<MenuTriggerProps<Payload>, 'children'>;
+}
+
+declare const DROPDOWN_MENU_CONTAINER_ATTR = "data-lobe-ui-dropdown-menu-container";
+declare const DropdownMenuRoot: typeof Menu$1.Root;
+declare const DropdownMenuSubmenuRoot: typeof Menu$1.SubmenuRoot;
+declare const DropdownMenuCheckboxItemIndicator: react__default.ForwardRefExoticComponent<_base_ui_react_menu.MenuCheckboxItemIndicatorProps & react__default.RefAttributes<HTMLSpanElement>>;
+type DropdownMenuTriggerProps = Omit<react__default.ComponentPropsWithRef<typeof Menu$1.Trigger>, 'children' | 'render'> & {
+    children: react__default.ReactNode;
+};
+declare const DropdownMenuTrigger: {
+    ({ children, className, nativeButton, ref: refProp, ...rest }: DropdownMenuTriggerProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type DropdownMenuPortalProps = react__default.ComponentProps<typeof Menu$1.Portal> & {
+    /**
+     * When `container` is not provided, it uses a shared container created by `usePortalContainer`.
+     */
+    container?: HTMLElement | null;
+};
+declare const DropdownMenuPortal: {
+    ({ container, ...rest }: DropdownMenuPortalProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type DropdownMenuPositionerProps = react__default.ComponentProps<typeof Menu$1.Positioner> & {
+    hoverTrigger?: boolean;
+    placement?: DropdownMenuPlacement;
+};
+declare const DropdownMenuPositioner: {
+    ({ className, placement, hoverTrigger, align, side, sideOffset, children, ...rest }: DropdownMenuPositionerProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type DropdownMenuPopupProps = react__default.ComponentProps<typeof Menu$1.Popup>;
+declare const DropdownMenuPopup: {
+    ({ className, ...rest }: DropdownMenuPopupProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type DropdownMenuItemProps = react__default.ComponentProps<typeof Menu$1.Item> & {
+    danger?: boolean;
+};
+declare const DropdownMenuItem: {
+    ({ className, danger, ...rest }: DropdownMenuItemProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type DropdownMenuCheckboxItemProps = react__default.ComponentProps<typeof Menu$1.CheckboxItem> & {
+    danger?: boolean;
+};
+declare const DropdownMenuCheckboxItemPrimitive: {
+    ({ className, danger, ...rest }: DropdownMenuCheckboxItemProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type DropdownMenuSeparatorProps = react__default.ComponentProps<typeof Menu$1.Separator>;
+declare const DropdownMenuSeparator: {
+    ({ className, ...rest }: DropdownMenuSeparatorProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const DropdownMenuGroup: react__default.ForwardRefExoticComponent<_base_ui_react_menu.MenuGroupProps & react__default.RefAttributes<Element>>;
+type DropdownMenuGroupLabelProps = react__default.ComponentProps<typeof Menu$1.GroupLabel>;
+declare const DropdownMenuGroupLabel: {
+    ({ className, ...rest }: DropdownMenuGroupLabelProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type DropdownMenuSubmenuTriggerProps = react__default.ComponentProps<typeof Menu$1.SubmenuTrigger> & {
+    danger?: boolean;
+};
+declare const DropdownMenuSubmenuTrigger: {
+    ({ className, danger, ...rest }: DropdownMenuSubmenuTriggerProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type DropdownMenuItemContentProps = react__default.HTMLAttributes<HTMLDivElement>;
+declare const DropdownMenuItemContent: {
+    ({ className, ...rest }: DropdownMenuItemContentProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type DropdownMenuItemIconProps = react__default.HTMLAttributes<HTMLSpanElement>;
+declare const DropdownMenuItemIcon: {
+    ({ className, ...rest }: DropdownMenuItemIconProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type DropdownMenuItemLabelProps = react__default.HTMLAttributes<HTMLSpanElement>;
+declare const DropdownMenuItemLabel: {
+    ({ className, ...rest }: DropdownMenuItemLabelProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type DropdownMenuItemExtraProps = react__default.HTMLAttributes<HTMLSpanElement>;
+declare const DropdownMenuItemExtra: {
+    ({ className, ...rest }: DropdownMenuItemExtraProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type DropdownMenuSubmenuArrowProps = react__default.HTMLAttributes<HTMLSpanElement>;
+declare const DropdownMenuSubmenuArrow: {
+    ({ className, ...rest }: DropdownMenuSubmenuArrowProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+declare const DropdownMenu: react.NamedExoticComponent<DropdownMenuProps<unknown>>;
+
+type ActionIconGroupEvent = Pick<MenuInfo, 'key' | 'keyPath' | 'domEvent'>;
+interface ActionIconGroupProps extends Omit<CenterProps, 'children'> {
+    actionIconProps?: Partial<Omit<ActionIconProps, 'icon' | 'size' | 'ref'>>;
+    disabled?: boolean;
+    glass?: boolean;
+    items?: MenuItemType[];
+    menu?: DropdownMenuProps['items'];
+    onActionClick?: (action: ActionIconGroupEvent) => void;
+    ref?: Ref<HTMLDivElement>;
+    shadow?: boolean;
+    size?: ActionIconProps['size'];
+    variant?: 'filled' | 'outlined' | 'borderless';
+}
+
+declare const ActionIconGroup: FC<ActionIconGroupProps>;
+
+interface AlertProps extends Omit<AlertProps$1, 'icon' | 'type'> {
+    classNames?: {
+        alert?: string;
+        container?: string;
+        extraContent?: string;
+    };
+    colorfulText?: boolean;
+    extra?: ReactNode;
+    extraDefaultExpand?: boolean;
+    extraIsolate?: boolean;
+    glass?: boolean;
+    icon?: IconProps$1['icon'];
+    iconProps?: Omit<IconProps$1, 'icon'>;
+    ref?: Ref<AlertRef>;
+    styles?: {
+        alert?: CSSProperties;
+        container?: CSSProperties;
+        extraContent?: CSSProperties;
+    };
+    text?: {
+        detail?: string;
+    };
+    type?: 'success' | 'info' | 'warning' | 'error' | 'secondary';
+    variant?: 'filled' | 'outlined' | 'borderless';
+}
+
+declare const Alert: react.NamedExoticComponent<AlertProps>;
+
+interface AutoCompleteProps extends AutoCompleteProps$1 {
+    shadow?: boolean;
+}
+
+declare const AutoComplete: react.NamedExoticComponent<AutoCompleteProps>;
+
+interface AvatarProps extends AvatarProps$1 {
+    animation?: boolean;
+    avatar?: string | ReactNode;
+    background?: string;
+    bordered?: boolean;
+    borderedColor?: string;
+    emojiScaleWithBackground?: boolean;
+    loading?: boolean;
+    ref?: Ref<HTMLDivElement>;
+    shadow?: boolean;
+    shape?: 'circle' | 'square';
+    size?: number;
+    sliceText?: boolean;
+    title?: string;
+    tooltipProps?: Omit<TooltipProps, 'children' | 'title'>;
+    unoptimized?: boolean;
+    variant?: 'borderless' | 'filled' | 'outlined';
+}
+interface AvatarGroupItemType extends Pick<AvatarProps, 'avatar' | 'title' | 'alt' | 'onClick' | 'style' | 'className' | 'loading'> {
+    key: string;
+}
+interface AvatarGroupProps extends Pick<AvatarProps, 'variant' | 'bordered' | 'shadow' | 'size' | 'background' | 'animation' | 'draggable' | 'shape'>, Omit<FlexboxProps, 'children' | 'onClick'> {
+    classNames?: {
+        avatar?: string;
+        count?: string;
+    };
+    items: AvatarGroupItemType[];
+    max?: number;
+    onClick?: (props: {
+        item: AvatarGroupItemType;
+        key: string;
+    }) => void;
+    ref?: Ref<HTMLDivElement>;
+    styles?: {
+        avatar?: CSSProperties;
+        count?: CSSProperties;
+    };
+    zIndexReverse?: boolean;
+}
+
+declare const AvatarGroup: react.NamedExoticComponent<AvatarGroupProps>;
+
+interface IAvatar {
+    (props: AvatarProps & RefAttributes<HTMLDivElement>): ReactNode;
+    Group: typeof AvatarGroup;
+}
+declare const Avatar: IAvatar;
+
+interface BurgerProps {
+    className?: string;
+    drawerProps?: Partial<Omit<DrawerProps$1, 'items' | 'opened' | 'setOpened'>>;
+    fullscreen?: boolean;
+    headerHeight?: number;
+    iconProps?: Partial<ActionIconProps>;
+    items: MenuProps$1['items'];
+    onClick?: MenuProps$1['onClick'];
+    openKeys?: MenuProps$1['openKeys'];
+    opened: boolean;
+    ref?: Ref<HTMLDivElement>;
+    rootClassName?: string;
+    selectedKeys?: MenuProps$1['selectedKeys'];
+    setOpened: (state: boolean) => void;
+    size?: ActionIconProps['size'];
+    style?: CSSProperties;
+    variant?: ActionIconProps['variant'];
+}
+
+declare const Burger: react.NamedExoticComponent<BurgerProps>;
+
+interface ButtonProps extends Omit<ButtonProps$1, 'icon'> {
+    glass?: boolean;
+    icon?: IconProps$1['icon'];
+    iconProps?: Partial<Omit<IconProps$1, 'icon'>>;
+    ref?: Ref<HTMLButtonElement | HTMLAnchorElement>;
+    shadow?: boolean;
+}
+
+declare const Button: FC<ButtonProps>;
+
+interface TextProps extends DivProps$1 {
+    align?: 'left' | 'center' | 'right';
+    as?: ElementType;
+    code?: boolean;
+    color?: string;
+    delete?: boolean;
+    disabled?: boolean;
+    ellipsis?: boolean | {
+        rows?: number;
+        tooltip?: boolean | string | TooltipProps;
+        tooltipWhenOverflow?: boolean;
+    };
+    fontSize?: number | string;
+    italic?: boolean;
+    /**
+     * Clamp lines with CSS line-clamp.
+     *
+     * Note: When `ellipsis` is provided, `ellipsis` takes precedence.
+     */
+    lineClamp?: number;
+    lineHeight?: CSSProperties['lineHeight'];
+    mark?: boolean;
+    /**
+     * Whether to disable wrapping (set `white-space: nowrap`).
+     *
+     * Note: When multi-line ellipsis is enabled, it will be ignored.
+     */
+    noWrap?: boolean;
+    ref?: Ref<HTMLDivElement>;
+    strong?: boolean;
+    textDecoration?: CSSProperties['textDecoration'];
+    textTransform?: CSSProperties['textTransform'];
+    type?: 'secondary' | 'success' | 'warning' | 'danger' | 'info';
+    underline?: boolean;
+    weight?: 'bold' | 'bolder' | number;
+    whiteSpace?: CSSProperties['whiteSpace'];
+    wordBreak?: CSSProperties['wordBreak'];
+}
+
+declare const Text: FC<TextProps>;
+
+interface CheckboxProps extends Omit<DivProps$1, 'onChange'> {
+    backgroundColor?: string;
+    checked?: boolean;
+    classNames?: {
+        checkbox?: string;
+        text?: string;
+        wrapper?: string;
+    };
+    defaultChecked?: boolean;
+    disabled?: boolean;
+    indeterminate?: boolean;
+    onChange?: (checked: boolean) => void;
+    shape?: 'square' | 'circle';
+    size?: number;
+    styles?: {
+        checkbox?: CSSProperties;
+        text?: CSSProperties;
+        wrapper?: CSSProperties;
+    };
+    textProps?: Omit<TextProps, 'children' | 'className' | 'style'>;
+}
+interface CheckboxGroupOption {
+    disabled?: boolean;
+    label: ReactNode;
+    value: string;
+}
+interface CheckboxGroupProps extends Omit<FlexboxProps, 'defaultValue' | 'onChange'> {
+    defaultValue?: string[];
+    disabled?: boolean;
+    onChange?: (value: string[]) => void;
+    options: string[] | CheckboxGroupOption[];
+    shape?: 'square' | 'circle';
+    size?: number;
+    textProps?: Omit<TextProps, 'children' | 'className' | 'style'>;
+    value?: string[];
+}
+
+declare const CheckboxGroup: FC<CheckboxGroupProps>;
+
+interface ICheckbox {
+    (props: CheckboxProps & RefAttributes<HTMLDivElement>): ReactNode;
+    Group: typeof CheckboxGroup;
+}
+declare const Checkbox: ICheckbox;
+
+type DiffViewMode = 'split' | 'unified';
+interface CodeDiffProps extends Omit<FlexboxProps, 'children'> {
+    /**
+     * Actions to render in the header
+     */
+    actionsRender?: (props: {
+        newContent: string;
+        oldContent: string;
+        originalNode: ReactNode;
+    }) => ReactNode;
+    /**
+     * Custom class names for different parts
+     */
+    classNames?: {
+        body?: string;
+        header?: string;
+    };
+    /**
+     * Options for the diff component
+     */
+    diffOptions?: FileDiffOptions<string>;
+    /**
+     * File name to display
+     */
+    fileName?: string;
+    /**
+     * Programming language for syntax highlighting
+     */
+    language?: string;
+    /**
+     * New content (after changes)
+     */
+    newContent: string;
+    /**
+     * Old content (before changes)
+     */
+    oldContent: string;
+    /**
+     * Whether to show file header
+     * @default true
+     */
+    showHeader?: boolean;
+    /**
+     * Custom styles for different parts
+     */
+    styles?: {
+        body?: CSSProperties;
+        header?: CSSProperties;
+    };
+    /**
+     * Visual variant
+     * @default 'filled'
+     */
+    variant?: 'filled' | 'outlined' | 'borderless';
+    /**
+     * View mode for diff display
+     * @default 'split'
+     */
+    viewMode?: DiffViewMode;
+}
+interface PatchDiffProps extends Omit<FlexboxProps, 'children'> {
+    /**
+     * Actions to render in the header
+     */
+    actionsRender?: (props: {
+        originalNode: ReactNode;
+        patch: string;
+    }) => ReactNode;
+    /**
+     * Custom class names for different parts
+     */
+    classNames?: {
+        body?: string;
+        header?: string;
+    };
+    /**
+     * Options for the diff component
+     */
+    diffOptions?: FileDiffOptions<string>;
+    /**
+     * File name to display (optional, extracted from patch if not provided)
+     */
+    fileName?: string;
+    /**
+     * Programming language for syntax highlighting
+     */
+    language?: string;
+    /**
+     * Unified diff patch string
+     */
+    patch: string;
+    /**
+     * Whether to show file header
+     * @default true
+     */
+    showHeader?: boolean;
+    /**
+     * Custom styles for different parts
+     */
+    styles?: {
+        body?: CSSProperties;
+        header?: CSSProperties;
+    };
+    /**
+     * Visual variant
+     * @default 'filled'
+     */
+    variant?: 'filled' | 'outlined' | 'borderless';
+    /**
+     * View mode for diff display
+     * @default 'split'
+     */
+    viewMode?: DiffViewMode;
+}
+
+declare const CodeDiff: react.NamedExoticComponent<CodeDiffProps>;
+
+declare const PatchDiff: react.NamedExoticComponent<PatchDiffProps>;
+
+interface CodeEditorProps extends TextAreaProps$1, Pick<FlexboxProps, 'width' | 'height' | 'flex'> {
+    classNames?: {
+        highlight?: string;
+        textarea?: string;
+    };
+    defaultValue?: string;
+    language: string;
+    onValueChange: (value: string) => void;
+    placeholder?: string;
+    ref?: Ref<HTMLTextAreaElement>;
+    style?: CSSProperties;
+    styles?: {
+        highlight?: CSSProperties;
+        textarea?: CSSProperties;
+    };
+    value: string;
+    variant?: 'filled' | 'outlined' | 'borderless';
+}
+
+declare const CodeEditor: react.NamedExoticComponent<CodeEditorProps>;
+
+interface CollapseItemType extends ItemType$1 {
+    desc?: ReactNode;
+    icon?: IconProps$1['icon'];
+}
+interface CollapseProps extends Omit<CollapseProps$1, 'collapsible' | 'ghost' | 'items'> {
+    classNames?: {
+        desc?: string;
+        header?: string;
+        title?: string;
+    };
+    collapsible?: boolean;
+    gap?: number;
+    items: CollapseItemType[];
+    padding?: number | string | {
+        body?: number | string;
+        header?: number | string;
+    };
+    ref?: Ref<HTMLDivElement>;
+    styles?: {
+        desc?: CSSProperties;
+        header?: CSSProperties;
+        title?: CSSProperties;
+    };
+    variant?: 'filled' | 'outlined' | 'borderless';
+}
+
+declare const Collapse: react.NamedExoticComponent<CollapseProps>;
+
+interface ColorSwatchesItemType {
+    color: string;
+    key?: Key;
+    title?: ReactNode;
+}
+interface ColorSwatchesProps extends Omit<FlexboxProps, 'onChange'> {
+    colors: ColorSwatchesItemType[];
+    defaultValue?: string;
+    enableColorPicker?: boolean;
+    enableColorSwatches?: boolean;
+    onChange?: (color?: string) => void;
+    ref?: Ref<HTMLDivElement>;
+    shape?: 'circle' | 'square';
+    size?: number;
+    texts?: {
+        custom: string;
+        presets: string;
+    };
+    value?: string;
+}
+
+declare const ColorSwatches: FC<ColorSwatchesProps>;
+
+type MotionComponentType = typeof motion_react.motion | typeof m;
+declare const MotionComponent: Context<MotionComponentType>;
+declare const MotionProvider: react.NamedExoticComponent<{
+    children: ReactNode;
+    motion: MotionComponentType;
+}>;
+declare const useMotionComponent: () => MotionComponentType;
+
+declare const _default$8: {
+    readonly 'sideNav.collapse': "Collapse sidebar";
+    readonly 'sideNav.demoActiveLabel': "Active";
+    readonly 'sideNav.demoFeatureAutoCollapseDesc': "Drag below threshold for smart collapse";
+    readonly 'sideNav.demoFeatureAutoCollapseTitle': "Auto-collapse";
+    readonly 'sideNav.demoFeaturePerformanceDesc': "No animation overhead for better performance";
+    readonly 'sideNav.demoFeaturePerformanceTitle': "Performance";
+    readonly 'sideNav.demoFeatureResizeDesc': "Drag to adjust panel width";
+    readonly 'sideNav.demoFeatureResizeTitle': "Flexible Resize";
+    readonly 'sideNav.demoFeatureSmartHandleDesc': "Hover to reveal toggle button";
+    readonly 'sideNav.demoFeatureSmartHandleTitle': "Smart Handle";
+    readonly 'sideNav.demoFeaturesTitle': "Features";
+    readonly 'sideNav.demoHint': "Try dragging the panel edge and using the toggle button ->";
+    readonly 'sideNav.demoSubtitle': "A workspace-style side panel with draggable resize";
+    readonly 'sideNav.demoTitle': "DraggableSideNav Demo";
+    readonly 'sideNav.expand': "Expand sidebar";
+};
+
+declare const _default$7: {
+    readonly 'messageModal.cancel': "Cancel";
+    readonly 'messageModal.confirm': "Confirm";
+    readonly 'messageModal.edit': "Edit";
+};
+
+declare const _default$6: {
+    readonly 'hotkey.conflict': "This shortcut conflicts with an existing one.";
+    readonly 'hotkey.invalidCombination': "Shortcut must include a modifier key (Ctrl, Alt, Shift) and only one regular key.";
+    readonly 'hotkey.placeholder': "Press keys to record shortcut";
+    readonly 'hotkey.reset': "Reset to default";
+};
+
+declare const _default$5: {
+    readonly 'form.reset': "Reset";
+    readonly 'form.submit': "Submit";
+    readonly 'form.unsavedChanges': "Unsaved changes";
+    readonly 'form.unsavedWarning': "You have unsaved changes. Are you sure you want to leave?";
+};
+
+declare const _default$4: {
+    readonly 'emojiPicker.delete': "Delete";
+    readonly 'emojiPicker.draggerDesc': "Click or Drag image to this area to upload";
+    readonly 'emojiPicker.emoji': "Emoji";
+    readonly 'emojiPicker.fileTypeError': "You can only upload image file!";
+    readonly 'emojiPicker.upload': "Upload";
+    readonly 'emojiPicker.uploadBtn': "Crop and Upload";
+};
+
+declare const _default$3: {
+    readonly 'editableMessage.addProps': "Add Props";
+    readonly 'editableMessage.delete': "Delete";
+    readonly 'editableMessage.input': "Input";
+    readonly 'editableMessage.inputPlaceholder': "Please enter sample input content";
+    readonly 'editableMessage.output': "Output";
+    readonly 'editableMessage.outputPlaceholder': "Please enter sample output content";
+    readonly 'editableMessage.system': "System";
+};
+
+declare const _default$2: {
+    readonly 'common.cancel': "Cancel";
+    readonly 'common.confirm': "Confirm";
+    readonly 'common.delete': "Delete";
+    readonly 'common.edit': "Edit";
+    readonly 'common.empty': "(empty)";
+};
+
+declare const _default$1: {
+    readonly 'chat.avatar': "avatar";
+    readonly 'chat.placeholder': "...";
+    readonly 'tokenTag.overload': "Overload";
+    readonly 'tokenTag.remained': "Remained";
+    readonly 'tokenTag.used': "Used";
+};
+
+type BuiltinTranslationResources = typeof _default$1 & typeof _default$2 & typeof _default$3 & typeof _default$4 & typeof _default$5 & typeof _default$6 & typeof _default$7 & typeof _default$8;
+type TranslationKey = keyof BuiltinTranslationResources;
+type TranslationValue = string;
+/**
+ * A (partial) dictionary of translations.
+ *
+ * Note: it's intentionally Partial so feature-level modules can pass only their own keys as
+ * fallback resources (e.g. `useTranslation(editableMessageMessages)`).
+ */
+type TranslationResources = Partial<Record<TranslationKey, TranslationValue>>;
+type TranslationResourcesMap = TranslationResources[] | Record<string, TranslationResources>;
+type TranslationResourcesInput = TranslationResourcesMap | Promise<TranslationResourcesMap>;
+
+type CDN = 'aliyun' | 'unpkg';
+interface CdnApi {
+    path: string;
+    pkg: string;
+    proxy?: CDN;
+    version?: string;
+}
+declare const genCdnUrl: ({ pkg, version, path, proxy }: CdnApi) => string;
+
+interface Config {
+    aAs?: ElementType;
+    customCdnFn?: CdnFn;
+    imgAs?: ElementType;
+    imgUnoptimized?: boolean;
+    proxy?: CDN | 'custom';
+}
+interface ConfigProviderProps {
+    children: ReactNode;
+    config?: Config;
+    locale?: string;
+    motion: MotionComponentType;
+    resources?: TranslationResourcesInput;
+}
+declare const ConfigProvider: react.NamedExoticComponent<ConfigProviderProps>;
+type CdnFn = ({ pkg, version, path }: CdnApi) => string;
+declare const useCdnFn: () => CdnFn;
+
+type ContextMenuCheckboxItem = MenuCheckboxItemType;
+type ContextMenuItem = BaseMenuItemType;
+
+type ContextMenuTriggerProps = {
+    children: ReactNode;
+    /**
+     * Menu items to display. Supports lazy rendering via function.
+     * When provided, context menu will be automatically shown on right-click.
+     */
+    items?: ContextMenuItem[] | (() => ContextMenuItem[]);
+    /**
+     * Custom context menu handler. If `items` is provided, this is optional.
+     */
+    onContextMenu?: (event: MouseEvent<HTMLElement>) => void;
+} & Omit<HTMLAttributes<HTMLElement>, 'onContextMenu' | 'children'>;
+declare const ContextMenuTrigger: react__default.NamedExoticComponent<ContextMenuTriggerProps>;
+
+declare const ContextMenuHost: react.MemoExoticComponent<() => react_jsx_runtime.JSX.Element | null>;
+
+interface ShowContextMenuOptions {
+    iconSpaceMode?: IconSpaceMode;
+}
+declare const showContextMenu: (items: ContextMenuItem[], options?: ShowContextMenuOptions) => void;
+/**
+ * Update menu items while keeping current anchor/position.
+ * Useful for interactive menu items (e.g. checkbox) to avoid re-positioning.
+ */
+declare const updateContextMenuItems: (items: ContextMenuItem[]) => void;
+declare const closeContextMenu: () => void;
+
+interface CopyButtonProps extends Omit<ActionIconProps, 'content'> {
+    content: string | (() => string);
+}
+
+declare const CopyButton: react.NamedExoticComponent<CopyButtonProps>;
+
+interface DatePickerProps extends DatePickerProps$1 {
+    shadow?: boolean;
+}
+
+declare const DatePicker: react.NamedExoticComponent<DatePickerProps>;
+
+interface DownloadButtonProps extends ActionIconProps {
+    blobUrl?: string;
+    fileName?: string;
+    fileType?: string;
+}
+
+declare const DownloadButton: react__default.NamedExoticComponent<DownloadButtonProps>;
+
+type DraggablePanelBodyProps = DivProps$1;
+declare const DraggablePanelBody: react.NamedExoticComponent<DivProps$1>;
+
+type DraggablePanelContainerProps = DivProps$1;
+declare const DraggablePanelContainer: react.NamedExoticComponent<DivProps$1>;
+
+type DraggablePanelFooterProps = DivProps$1;
+declare const DraggablePanelFooter: react.NamedExoticComponent<DivProps$1>;
+
+interface DraggablePanelHeaderProps extends Omit<DivProps$1, 'children'> {
+    pin?: boolean;
+    position?: 'left' | 'right';
+    setExpand?: (expand: boolean) => void;
+    setPin?: (pin: boolean) => void;
+    title?: string;
+}
+declare const DraggablePanelHeader: react.NamedExoticComponent<DraggablePanelHeaderProps>;
+
+type PlacementType = 'right' | 'left' | 'top' | 'bottom';
+interface DraggablePanelProps extends DivProps$1 {
+    backgroundColor?: string;
+    classNames?: {
+        content?: string;
+        handle?: string;
+    };
+    defaultExpand?: boolean;
+    defaultSize?: Partial<Size>;
+    destroyOnClose?: boolean;
+    expand?: boolean;
+    expandable?: boolean;
+    fullscreen?: boolean;
+    headerHeight?: number;
+    maxHeight?: number;
+    maxWidth?: number;
+    minHeight?: number;
+    minWidth?: number;
+    mode?: 'fixed' | 'float';
+    onExpandChange?: (expand: boolean) => void;
+    onSizeChange?: (delta: NumberSize, size?: Size) => void;
+    onSizeDragging?: (delta: NumberSize, size?: Size) => void;
+    pin?: boolean;
+    placement: PlacementType;
+    resize?: Props$1['enableResizing'];
+    /**
+     * Whether to show border
+     * @default true
+     */
+    showBorder?: boolean;
+    showHandleHighlight?: boolean;
+    showHandleWhenCollapsed?: boolean;
+    showHandleWideArea?: boolean;
+    size?: Partial<Size>;
+    styles?: {
+        content?: CSSProperties;
+        handle?: CSSProperties;
+    };
+}
+
+interface IDraggablePanel {
+    (props: DraggablePanelProps & RefAttributes<HTMLDivElement>): ReactNode;
+    Body: typeof DraggablePanelBody;
+    Container: typeof DraggablePanelContainer;
+    Footer: typeof DraggablePanelFooter;
+    Header: typeof DraggablePanelHeader;
+}
+declare const DraggablePanel: IDraggablePanel;
+
+interface DraggableSideNavProps extends Omit<DivProps$1, 'children' | 'onSelect'> {
+    backgroundColor?: string;
+    /**
+     * Body content (main content area)
+     * Function that receives expand state
+     */
+    body: (expand: boolean) => ReactNode;
+    /**
+     * Classnames for internal components
+     */
+    classNames?: {
+        body?: string;
+        container?: string;
+        content?: string;
+        footer?: string;
+        handle?: string;
+        header?: string;
+    };
+    /**
+     * Whether the panel is expanded by default
+     * @default true
+     */
+    defaultExpand?: boolean;
+    /**
+     * Default width (number format)
+     */
+    defaultWidth?: number;
+    /**
+     * Whether the panel is expanded (controlled)
+     */
+    expand?: boolean;
+    /**
+     * Whether the panel can be expanded/collapsed
+     * @default true
+     */
+    expandable?: boolean;
+    /**
+     * Footer content
+     * Can be a static element or a function that receives expand state
+     */
+    footer?: ReactNode | ((expand: boolean) => ReactNode);
+    /**
+     * Header content
+     * Can be a static element or a function that receives expand state
+     */
+    header?: ReactNode | ((expand: boolean) => ReactNode);
+    /**
+     * Maximum width
+     */
+    maxWidth?: number;
+    /**
+     * Minimum width when expanded (does not affect collapsed width which is always 64px)
+     * Only applies when the panel is in expanded state
+     * @default 64
+     */
+    minWidth?: number;
+    /**
+     * Callback when expand state changes
+     */
+    onExpandChange?: (expand: boolean) => void;
+    /**
+     * Callback when menu item is selected
+     */
+    onSelect?: (key: string) => void;
+    /**
+     * Callback when width changes
+     */
+    onWidthChange?: (delta: NumberSize, width: number) => void;
+    /**
+     * Callback when actively resizing width
+     */
+    onWidthDragging?: (delta: NumberSize, width: number) => void;
+    /**
+     * Placement of the side nav
+     * @default 'left'
+     */
+    placement?: 'left' | 'right';
+    /**
+     * Whether to enable resizing
+     * @default true
+     */
+    resizable?: boolean;
+    /**
+     * Whether to show border
+     * @default true
+     */
+    showBorder?: boolean;
+    /**
+     * Whether to show handle for toggling
+     * @default true
+     */
+    showHandle?: boolean;
+    showHandleHighlight?: boolean;
+    /**
+     * Whether to show handle when collapsed
+     * @default false
+     */
+    showHandleWhenCollapsed?: boolean;
+    /**
+     * Custom styles
+     */
+    styles?: {
+        body?: CSSProperties;
+        container?: CSSProperties;
+        content?: CSSProperties;
+        footer?: CSSProperties;
+        handle?: CSSProperties;
+        header?: CSSProperties;
+    };
+    /**
+     * Expanded width (controlled)
+     * This represents the width when expanded, not the current displayed width
+     * The actual displayed width will be `width` when expanded, or `minWidth` when collapsed
+     */
+    width?: number;
+}
+
+declare const DraggableSideNav: react.NamedExoticComponent<DraggableSideNavProps>;
+
+interface DrawerProps extends Omit<DrawerProps$1, 'styles' | 'classNames'> {
+    classNames?: DrawerProps$1['classNames'] & {
+        bodyContent?: string;
+        extra?: string;
+        sidebar?: string;
+        sidebarContent?: string;
+        title?: string;
+    };
+    closeIconProps?: ActionIconProps;
+    containerMaxWidth?: number | string;
+    noHeader?: boolean;
+    ref?: Ref<HTMLDivElement>;
+    sidebar?: ReactNode;
+    sidebarWidth?: number;
+    styles?: DrawerProps$1['styles'] & {
+        bodyContent?: CSSProperties;
+        extra?: CSSProperties;
+        sidebar?: CSSProperties;
+        sidebarContent?: CSSProperties;
+        title?: CSSProperties;
+    };
+}
+
+declare const Drawer: react.NamedExoticComponent<DrawerProps>;
+
+interface DropdownProps extends Omit<DropdownProps$1, 'menu'> {
+    iconProps?: IconContentConfig;
+    menu: MenuProps;
+}
+
+/**
+ * @deprecated
+ * Use `DropdownMenu` or `ContextMenu` instead
+ * @see https://ui.lobehub.com/components/context-menu
+ * @see https://ui.lobehub.com/components/dropdown-menu
+ */
+declare const Dropdown: react.NamedExoticComponent<DropdownProps>;
+
+interface InputProps extends InputProps$1 {
+    ref?: Ref<InputRef>;
+    shadow?: boolean;
+}
+interface TextAreaProps extends TextAreaProps$2 {
+    ref?: Ref<TextAreaRef>;
+    resize?: boolean;
+    shadow?: boolean;
+}
+interface InputNumberProps extends InputNumberProps$1 {
+    ref?: Ref<InputNumberRef>;
+    shadow?: boolean;
+}
+interface InputPasswordProps extends PasswordProps {
+    ref?: Ref<InputRef>;
+    shadow?: boolean;
+}
+interface InputOPTProps extends OTPProps {
+    ref?: Ref<OTPRef>;
+    shadow?: boolean;
+}
+
+declare const Input: react.NamedExoticComponent<InputProps>;
+
+declare const InputNumber: react.NamedExoticComponent<InputNumberProps>;
+
+declare const InputOPT: react.NamedExoticComponent<InputOPTProps>;
+
+declare const InputPassword: react.NamedExoticComponent<InputPasswordProps>;
+
+declare const TextArea: react.NamedExoticComponent<TextAreaProps>;
+
+interface ControlInputProps extends Omit<InputProps, 'onChange' | 'value' | 'onAbort'> {
+    onChange?: (value: string) => void;
+    onChangeEnd?: (value: string) => void;
+    onValueChanging?: (value: string) => void;
+    submitIcon?: ActionIconProps['icon'];
+    texts?: {
+        reset?: string;
+        submit?: string;
+    };
+    value?: string;
+}
+
+interface EditableTextProps extends Omit<FlexboxProps, 'onChange' | 'onBlur' | 'onFocus'>, Pick<ControlInputProps, 'onChange' | 'value' | 'onChangeEnd' | 'onValueChanging' | 'texts' | 'variant' | 'onBlur' | 'onFocus' | 'size'> {
+    className?: string;
+    classNames?: {
+        container?: string;
+        input?: string;
+    };
+    editing?: boolean;
+    inputProps?: Omit<ControlInputProps, 'onChange' | 'value' | 'onChangeEnd' | 'onValueChanging' | 'texts' | 'className' | 'style' | 'onBlur' | 'onFocus' | 'size'>;
+    onEditingChange?: (editing: boolean) => void;
+    showEditIcon?: boolean;
+    style?: CSSProperties;
+    styles?: {
+        container?: CSSProperties;
+        input?: CSSProperties;
+    };
+}
+
+declare const EditableText: react.NamedExoticComponent<EditableTextProps>;
+
+declare const EditorSlashMenuList: react__default.ForwardRefExoticComponent<Omit<_base_ui_react_autocomplete.AutocompleteListProps & react__default.RefAttributes<HTMLDivElement>, "ref"> & react__default.RefAttributes<HTMLDivElement>>;
+type EditorSlashMenuPortalProps = react__default.ComponentProps<typeof Autocomplete.Portal> & {
+    /**
+     * When `container` is not provided, it uses a shared container created by `usePortalContainer`.
+     */
+    container?: HTMLElement | null;
+};
+declare const EditorSlashMenuPortal: {
+    ({ container, ...rest }: EditorSlashMenuPortalProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type EditorSlashMenuPositionerProps = react__default.ComponentProps<typeof Autocomplete.Positioner>;
+declare const EditorSlashMenuPositioner: {
+    ({ className, align, positionMethod, side, sideOffset, ...rest }: EditorSlashMenuPositionerProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type EditorSlashMenuPopupProps = react__default.ComponentProps<typeof Autocomplete.Popup>;
+declare const EditorSlashMenuPopup: {
+    ({ className, initialFocus, ...rest }: EditorSlashMenuPopupProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const EditorSlashMenuGroup$1: react__default.ForwardRefExoticComponent<_base_ui_react_autocomplete.AutocompleteGroupProps & react__default.RefAttributes<HTMLDivElement>>;
+type EditorSlashMenuHiddenInputProps = react__default.ComponentProps<typeof Autocomplete.Input>;
+declare const EditorSlashMenuHiddenInput: {
+    ({ className, ...rest }: EditorSlashMenuHiddenInputProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+type EditorSlashMenuItemValue = string;
+type EditorSlashMenuOption = {
+    /** Render danger style (red) */
+    danger?: boolean;
+    /** Whether the item is disabled */
+    disabled?: boolean;
+    /** Optional extra content shown at the end */
+    extra?: react__default.ReactNode;
+    /** Optional icon shown at the start */
+    icon?: react__default.ReactNode;
+    /** Optional additional keywords for filtering */
+    keywords?: string[];
+    /** Visible label, also used for filtering by default */
+    label: string;
+    /** Unique id of the command */
+    value: EditorSlashMenuItemValue;
+};
+type EditorSlashMenuGroup = {
+    items: EditorSlashMenuOption[];
+    /** Optional group title */
+    label?: string;
+};
+type EditorSlashMenuItems = Array<EditorSlashMenuOption | EditorSlashMenuGroup>;
+
+type Props = {
+    /** Anchor for positioning (caret virtual element, dom element, ref, etc.) */
+    anchor?: react__default.ComponentProps<typeof EditorSlashMenuPositioner>['anchor'];
+    defaultOpen?: boolean;
+    /** Initial query string (uncontrolled) */
+    defaultValue?: string;
+    /** Optional custom empty state */
+    empty?: react__default.ReactNode;
+    hiddenInputProps?: react__default.ComponentProps<typeof EditorSlashMenuHiddenInput>;
+    items: EditorSlashMenuItems;
+    listProps?: react__default.ComponentProps<typeof EditorSlashMenuList>;
+    onOpenChange?: (open: boolean, details: AutocompleteRootChangeEventDetails) => void;
+    onOpenChangeComplete?: (open: boolean) => void;
+    /** Called when a command is selected. */
+    onSelect?: (item: EditorSlashMenuOption, details: AutocompleteRootChangeEventDetails) => void;
+    /** Called when query changes. By default, changes caused by item selection are ignored. */
+    onValueChange?: (value: string, details: AutocompleteRootChangeEventDetails) => void;
+    open?: boolean;
+    popupProps?: react__default.ComponentProps<typeof EditorSlashMenuPopup>;
+    portalProps?: Omit<react__default.ComponentProps<typeof EditorSlashMenuPortal>, 'container'> & {
+        container?: HTMLElement | null;
+    };
+    positionerProps?: Omit<react__default.ComponentProps<typeof EditorSlashMenuPositioner>, 'anchor'>;
+    /** Optional custom group label renderer */
+    renderGroupLabel?: (label: string) => react__default.ReactNode;
+    /** Optional custom item renderer */
+    renderItem?: (item: EditorSlashMenuOption) => react__default.ReactNode;
+    /** Reserve icon space even when icon is missing */
+    reserveIconSpace?: boolean;
+    /** Pass-through props */
+    rootProps?: Omit<AutocompleteRootProps<EditorSlashMenuOption>, 'items' | 'value' | 'defaultValue' | 'onValueChange' | 'open' | 'defaultOpen' | 'onOpenChange' | 'onOpenChangeComplete' | 'itemToStringValue'>;
+    /** Whether selecting an item should propagate its filled value via `onValueChange`. */
+    updateValueOnSelect?: boolean;
+    /** Current query string (controlled) */
+    value?: string;
+    /**
+     * Render a visually-hidden input element for keyboard navigation / screen readers.
+     * Default is `false` because slash menus usually live inside an editor input.
+     */
+    withHiddenInput?: boolean;
+};
+declare const EditorSlashMenu: react__default.NamedExoticComponent<Props>;
+
+declare const PopoverArrowIcon: react_jsx_runtime.JSX.Element;
+
+type PopoverPlacement = Placement;
+type PopoverTrigger = Trigger;
+/**
+ * Base UI Positioner props that can be passed through
+ */
+type PopoverPositionerProps = Omit<PopoverPositionerProps$1, 'className' | 'style' | 'children'>;
+/**
+ * Base UI Trigger props that can be passed through
+ */
+type PopoverTriggerComponentProps = Omit<PopoverTriggerProps, 'className' | 'style' | 'children' | 'render' | 'nativeButton' | 'handle' | 'payload'>;
+/**
+ * Base UI Popup props that can be passed through
+ */
+type PopoverPopupProps = Omit<PopoverPopupProps$1, 'className' | 'style' | 'children'>;
+/**
+ * Base UI Backdrop props that can be passed through
+ */
+type PopoverBackdropProps = Omit<PopoverBackdropProps$1, 'className' | 'style'>;
+/**
+ * Base UI Portal props that can be passed through
+ */
+type PopoverPortalProps = Omit<PopoverPortalProps$1, 'children' | 'container'>;
+interface PopoverProps {
+    /**
+     * 是否显示箭头, 在 `inset` 下无法使用
+     * @default false
+     */
+    arrow?: boolean;
+    /**
+     * Base UI Backdrop 组件的 props
+     */
+    backdropProps?: PopoverBackdropProps;
+    /**
+     * 触发元素
+     */
+    children: ReactElement | ReactNode;
+    /**
+     * 弹出容器类名
+     */
+    className?: string;
+    /**
+     * 自定义类名
+     */
+    classNames?: {
+        arrow?: string;
+        content?: string;
+        root?: string;
+        trigger?: string;
+    };
+    /**
+     * 关闭延迟（毫秒），优先级高于 mouseLeaveDelay
+     */
+    closeDelay?: number;
+    /**
+     * 弹出内容
+     */
+    content: ReactNode;
+    /**
+     * 默认打开状态
+     * @default false
+     */
+    defaultOpen?: boolean;
+    /**
+     * 是否禁用
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * 获取弹出容器
+     */
+    getPopupContainer?: (triggerNode: HTMLElement) => HTMLElement;
+    /**
+     * 是否嵌入 trigger 内部显示
+     * @default false
+     */
+    inset?: boolean;
+    /**
+     * 鼠标移入延迟（秒）
+     * @default 0.1
+     */
+    mouseEnterDelay?: number;
+    /**
+     * 鼠标移出延迟（秒）
+     * @default 0.1
+     */
+    mouseLeaveDelay?: number;
+    /**
+     * 是否使用原生 button 元素作为触发器
+     */
+    nativeButton?: boolean;
+    /**
+     * 打开状态变化回调
+     */
+    onOpenChange?: (open: boolean) => void;
+    /**
+     * 受控的打开状态
+     */
+    open?: boolean;
+    /**
+     * 打开延迟（毫秒），优先级高于 mouseEnterDelay
+     */
+    openDelay?: number;
+    /**
+     * 弹出位置
+     * @default 'top'
+     */
+    placement?: PopoverPlacement;
+    /**
+     * Base UI Popup 组件的 props
+     */
+    popupProps?: PopoverPopupProps;
+    /**
+     * Base UI Portal 组件的 props
+     */
+    portalProps?: PopoverPortalProps;
+    /**
+     * Base UI Positioner 组件的 props
+     */
+    positionerProps?: PopoverPositionerProps;
+    /**
+     * ref
+     */
+    ref?: ComponentPropsWithRef<typeof Popover$1.Trigger>['ref'];
+    /**
+     * 当设置为 true 时，即使在 PopoverGroup 内部也会独立渲染，忽略 group 单例行为
+     */
+    standalone?: boolean;
+    /**
+     * 自定义样式
+     */
+    styles?: {
+        arrow?: CSSProperties;
+        content?: CSSProperties;
+        root?: CSSProperties;
+    };
+    /**
+     * 触发方式
+     * @default 'hover'
+     */
+    trigger?: Trigger;
+    /**
+     * Base UI Trigger 组件的 props
+     */
+    triggerProps?: PopoverTriggerComponentProps;
+    /**
+     * z-index
+     */
+    zIndex?: number;
+}
+
+declare const PopoverRoot: typeof Popover$1.Root;
+declare const PopoverBackdrop: react.ForwardRefExoticComponent<_base_ui_react_popover.PopoverBackdropProps & react.RefAttributes<HTMLDivElement>>;
+type PopoverTriggerElementProps = Omit<ComponentPropsWithRef<typeof Popover$1.Trigger>, 'children' | 'render'> & {
+    children: ComponentProps<typeof Popover$1.Trigger>['children'];
+};
+declare const PopoverTriggerElement: {
+    ({ children, className, nativeButton, ref: refProp, ...rest }: PopoverTriggerElementProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type PopoverPortalAtomProps = Omit<ComponentProps<typeof Popover$1.Portal>, 'container'> & {
+    /**
+     * Portal container. When not provided, it uses the shared container created by `usePopoverPortalContainer`.
+     */
+    container?: HTMLElement | null;
+    /**
+     * Root element used by `usePopoverPortalContainer` to create the default container.
+     */
+    root?: HTMLElement | ShadowRoot | null;
+};
+declare const PopoverPortal: {
+    ({ container, root, children, ...rest }: PopoverPortalAtomProps): react_jsx_runtime.JSX.Element | null;
+    displayName: string;
+};
+type PopoverPositionerAtomProps = ComponentProps<typeof Popover$1.Positioner> & {
+    hoverTrigger?: boolean;
+    placement?: PopoverPlacement;
+};
+declare const PopoverPositioner: {
+    ({ children, className, hoverTrigger, placement, align, side, sideOffset, ...rest }: PopoverPositionerAtomProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type PopoverPopupAtomProps = ComponentProps<typeof Popover$1.Popup>;
+declare const PopoverPopup: {
+    ({ className, ...rest }: PopoverPopupAtomProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type PopoverArrowAtomProps = ComponentProps<typeof Popover$1.Arrow>;
+declare const PopoverArrow: {
+    ({ className, children, ...rest }: PopoverArrowAtomProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type PopoverViewportAtomProps = ComponentProps<typeof Popover$1.Viewport>;
+declare const PopoverViewport: {
+    ({ className, ...rest }: PopoverViewportAtomProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+type PopoverContextValue = {
+    close: () => void;
+};
+declare const PopoverProvider: react.NamedExoticComponent<{
+    children: ReactNode;
+    value: PopoverContextValue;
+}>;
+declare const usePopoverContext: () => PopoverContextValue;
+
+declare const Popover: FC<PopoverProps>;
+
+type PopoverGroupSharedProps = Omit<PopoverProps, 'children' | 'content' | 'defaultOpen' | 'open' | 'ref'> & {
+    /**
+     * @description Whether to enable content layout animation when switching triggers
+     * @default false
+     */
+    contentLayoutAnimation?: boolean;
+    /**
+     * Disable the "destroy on invalid trigger (display:none / disconnected)" guard for performance.
+     * @default false
+     */
+    disableDestroyOnInvalidTrigger?: boolean;
+    /**
+     * Disable the "hide when positioner falls back to (0,0)" visual guard for performance.
+     * @default false
+     */
+    disableZeroOriginGuard?: boolean;
+};
+
+type PopoverGroupProps = PopoverGroupSharedProps & {
+    children: ReactNode;
+};
+declare const PopoverGroup: FC<PopoverGroupProps>;
+
+declare const POPOVER_CONTAINER_ATTR = "data-lobe-ui-popover-container";
+declare const usePopoverPortalContainer: (root?: HTMLElement | ShadowRoot | null) => HTMLElement | null;
+
+interface AvatarUploaderProps {
+    compressSize?: number;
+    onChange: (avatar: string) => void;
+    onUpload?: (file: File) => void;
+    shape?: 'circle' | 'square';
+    texts?: {
+        draggerDesc?: string;
+        fileTypeError?: string;
+        uploadBtn?: string;
+    };
+}
+interface EmojiPickerCustomEmoji {
+    emojis: [
+        {
+            id: string;
+            keywords?: string[];
+            name: string;
+            skins: {
+                src: string;
+            }[];
+        }
+    ];
+    id: string;
+    name: string;
+}
+interface EmojiPickerCustomTab {
+    label: ReactNode;
+    render: (handleAvatarChange: (avatar: string) => void) => ReactNode;
+    value: string;
+}
+interface EmojiPickerProps extends Omit<AvatarProps, 'onChange' | 'avatar'> {
+    allowDelete?: boolean;
+    allowUpload?: boolean | {
+        enableEmoji?: boolean;
+    };
+    compressSize?: number;
+    contentProps?: Omit<FlexboxProps, 'className' | 'ref' | 'style'>;
+    customEmojis?: EmojiPickerCustomEmoji[];
+    customRender?: (avatar: string) => ReactNode;
+    customTabs?: EmojiPickerCustomTab[];
+    defaultAvatar?: string;
+    defaultOpen?: boolean;
+    loading?: boolean;
+    locale?: string;
+    onChange?: (emoji: string) => void;
+    onDelete?: () => void;
+    onOpenChange?: (open: boolean) => void;
+    onUpload?: AvatarUploaderProps['onUpload'];
+    open?: boolean;
+    popupClassName?: string;
+    popupProps?: Omit<PopoverProps, 'onOpenChange' | 'defaultOpen' | 'content' | 'open' | 'trigger' | 'children'>;
+    popupStyle?: CSSProperties;
+    size?: number;
+    texts?: AvatarUploaderProps['texts'] & {
+        delete?: string;
+        emoji?: string;
+        upload?: string;
+    };
+    value?: string;
+}
+
+declare const EmojiPicker: react.NamedExoticComponent<EmojiPickerProps>;
+
+interface EmptyProps extends Omit<FlexboxProps, 'title'> {
+    action?: ReactNode;
+    actionProps?: Omit<FlexboxProps, 'children'>;
+    description?: ReactNode;
+    descriptionProps?: Omit<TextProps, 'children'>;
+    emoji?: string;
+    icon?: IconProps$1['icon'];
+    iconColor?: IconProps$1['color'];
+    image?: ReactNode;
+    imageProps?: Omit<BlockProps, 'children'>;
+    imageSize?: number;
+    title?: ReactNode;
+    titleProps?: Omit<TextProps, 'children'>;
+    type?: 'default' | 'page';
+}
+
+declare const Empty: FC<EmptyProps>;
+
+type IconProps = SvgProps & DivProps$1;
+interface FileTypeIconProps extends IconProps {
+    color?: string;
+    filetype?: string;
+    icon?: ReactNode;
+    ref?: Ref<HTMLDivElement>;
+    size?: number;
+    type?: 'file' | 'folder';
+    variant?: 'color' | 'mono';
+}
+
+declare const FileTypeIcon: FC<FileTypeIconProps>;
+
+type EmojiType = 'anim' | 'flat' | 'modern' | 'mono' | 'raw' | '3d';
+
+interface FluentEmojiProps extends DivProps$1 {
+    emoji: string;
+    ref?: Ref<HTMLImageElement>;
+    size?: number;
+    type?: EmojiType;
+    unoptimized?: boolean;
+}
+
+declare const FluentEmoji: FC<FluentEmojiProps>;
+
+interface FontLoaderProps {
+    url: string;
+}
+declare const FontLoader: react.NamedExoticComponent<FontLoaderProps>;
+
+interface FooterProps extends FlexboxProps {
+    bottom?: ReactNode;
+    columns: FooterProps$1['columns'];
+    contentMaxWidth?: number;
+    theme?: 'light' | 'dark';
+}
+
+declare const Footer: react.NamedExoticComponent<FooterProps>;
+
+interface TagProps extends Omit<TagProps$1, 'color' | 'variant'> {
+    color?: TagProps$1['color'] | 'info';
+    ref?: Ref<HTMLDivElement>;
+    size?: 'small' | 'middle' | 'large';
+    variant?: 'filled' | 'outlined' | 'borderless';
+}
+
+declare const Tag: FC<TagProps>;
+
+type FormVariant = 'filled' | 'outlined' | 'borderless';
+type ItemsType = 'group' | 'flat';
+interface FormProps extends Omit<FormProps$1, 'variant'> {
+    activeKey?: (string | number)[];
+    children?: ReactNode;
+    classNames?: FormGroupProps['classNames'] & {
+        group?: string;
+        item?: string;
+    };
+    collapsible?: boolean;
+    defaultActiveKey?: (string | number)[];
+    footer?: ReactNode;
+    gap?: number | string;
+    itemMinWidth?: FormItemProps['minWidth'];
+    itemVariant?: FormProps$1['variant'];
+    items?: FormGroupItemType[] | FormItemProps[];
+    itemsType?: ItemsType;
+    onCollapse?: (key: (string | number)[]) => void;
+    ref?: Ref<FormInstance>;
+    styles?: FormGroupProps['styles'] & {
+        group?: CSSProperties;
+        item?: CSSProperties;
+    };
+    variant?: FormVariant;
+}
+interface FormGroupItemType {
+    children: FormItemProps[] | ReactNode;
+    collapsible?: boolean;
+    defaultActive?: boolean;
+    desc?: ReactNode;
+    extra?: ReactNode;
+    icon?: IconProps$1['icon'];
+    key?: string;
+    title: ReactNode;
+    variant?: FormVariant;
+}
+interface FormGroupProps extends Omit<CollapseProps, 'collapsible' | 'items' | 'defaultActiveKey' | 'activeKey' | 'variant'> {
+    active?: boolean;
+    children: ReactNode;
+    collapsible?: boolean;
+    defaultActive?: boolean;
+    desc?: ReactNode;
+    extra?: ReactNode;
+    icon?: IconProps$1['icon'];
+    keyValue?: string | number;
+    onCollapse?: (active: boolean) => void;
+    title?: ReactNode;
+    variant?: FormVariant;
+}
+interface FormItemProps extends FormItemProps$1 {
+    avatar?: FormTitleProps['avatar'];
+    desc?: FormTitleProps['desc'];
+    divider?: boolean;
+    hidden?: boolean;
+    minWidth?: string | number;
+    tag?: FormTitleProps['tag'];
+    variant?: FormVariant;
+}
+interface FormSubmitFooterProps extends Omit<FlexboxProps, 'onReset'> {
+    buttonProps?: Omit<ButtonProps, 'children'>;
+    children?: ReactNode;
+    enableReset?: boolean;
+    enableUnsavedWarning?: boolean;
+    float?: boolean;
+    onReset?: (value: any, preValue: any) => void;
+    resetButtonProps?: Omit<ButtonProps, 'children'>;
+    saveButtonProps?: Omit<ButtonProps, 'children'>;
+    texts?: {
+        reset?: string;
+        submit?: string;
+        unSaved?: string;
+        unSavedWarning?: string;
+    };
+}
+interface FormTitleProps extends Omit<FlexboxProps, 'title'> {
+    avatar?: ReactNode;
+    classNames?: {
+        content?: string;
+        desc?: string;
+        tag?: string;
+        title?: string;
+    };
+    desc?: ReactNode;
+    styles?: {
+        content?: CSSProperties;
+        desc?: CSSProperties;
+        tag?: CSSProperties;
+        title?: CSSProperties;
+    };
+    tag?: string;
+    tagProps?: Omit<TagProps, 'children'>;
+    title: ReactNode;
+}
+
+declare const FormGroup: react.NamedExoticComponent<FormGroupProps>;
+
+declare const FormItem: react.NamedExoticComponent<FormItemProps>;
+
+declare const FormSubmitFooter: react.NamedExoticComponent<FormSubmitFooterProps>;
+
+declare const FormTitle: FC<FormTitleProps>;
+
+interface IForm {
+    (props: FormProps & RefAttributes<FormInstance>): ReactNode;
+    Group: typeof FormGroup;
+    Item: typeof FormItem;
+    Provider: typeof Form$1.Provider;
+    SubmitFooter: typeof FormSubmitFooter;
+    Title: typeof FormTitle;
+    useForm: typeof Form$1.useForm;
+}
+declare const Form: IForm;
+
+type ModalProps = Omit<ModalProps$1, 'okType' | 'wrapClassName'> & {
+    allowFullscreen?: boolean;
+    enableResponsive?: boolean;
+    paddings?: {
+        desktop?: number;
+        mobile?: number;
+    };
+};
+type ModalContextValue = {
+    close: () => void;
+    setCanDismissByClickOutside: (value: boolean) => void;
+};
+type ModalInstance = ModalContextValue & {
+    destroy: () => void;
+    update: (nextProps: Partial<ImperativeModalProps>) => void;
+};
+type ImperativeModalProps = ModalProps;
+type RawModalComponentProps = {
+    onClose: () => void;
+    open: boolean;
+};
+type RawModalComponent<P = any> = ComponentType<P>;
+type RawModalOptions<OpenKey extends PropertyKey = 'open', CloseKey extends PropertyKey = 'onClose'> = {
+    destroyDelay?: number;
+    destroyOnClose?: boolean;
+    onCloseKey?: CloseKey;
+    openKey?: OpenKey;
+};
+type RawModalKeyOptions<OpenKey extends PropertyKey = 'open', CloseKey extends PropertyKey = 'onClose'> = RawModalOptions<OpenKey, CloseKey> & {
+    onCloseKey: CloseKey;
+    openKey: OpenKey;
+};
+type RawModalInstance<P = any, OpenKey extends PropertyKey = 'open', CloseKey extends PropertyKey = 'onClose'> = ModalContextValue & {
+    destroy: () => void;
+    update: (nextProps: Partial<Omit<P, Extract<OpenKey, keyof P> | Extract<CloseKey, keyof P>>>) => void;
+};
+
+type ModalHostProps = {
+    root?: HTMLElement | ShadowRoot | null;
+};
+declare const ModalHost: ({ root }: ModalHostProps) => react_jsx_runtime.JSX.Element | null;
+declare const createModal: (props: ImperativeModalProps) => ModalInstance;
+declare function createRawModal<P extends RawModalComponentProps>(component: RawModalComponent<P>, props: Omit<P, 'open' | 'onClose'>, options?: RawModalOptions): RawModalInstance<P>;
+declare function createRawModal<P, OpenKey extends keyof P, CloseKey extends keyof P>(component: RawModalComponent<P>, props: Omit<P, OpenKey | CloseKey>, options: RawModalKeyOptions<OpenKey, CloseKey>): RawModalInstance<P, OpenKey, CloseKey>;
+
+declare const Modal: react.NamedExoticComponent<ModalProps>;
+
+declare const ModalProvider: react.NamedExoticComponent<{
+    children: ReactNode;
+    value: ModalContextValue;
+}>;
+declare const useModalContext: () => ModalContextValue;
+
+type PickModalProps = Pick<ModalProps, 'style' | 'className' | 'allowFullscreen' | 'title' | 'width' | 'onCancel' | 'open' | 'centered' | 'destroyOnHidden' | 'paddings' | 'height' | 'enableResponsive' | 'afterClose' | 'afterOpenChange' | 'zIndex' | 'mask' | 'getContainer' | 'keyboard' | 'forceRender' | 'focusTriggerAfterClose' | 'closable' | 'loading' | 'closeIcon'>;
+type PickFormProps = Omit<FormProps, 'className' | 'style' | 'title' | 'styles' | 'classNames'>;
+interface FormModalProps extends PickModalProps, PickFormProps {
+    classNames?: ModalProps['classNames'] & {
+        form?: FormProps['className'];
+    };
+    onSubmit?: ModalProps['onOk'];
+    ref?: Ref<FormInstance>;
+    styles?: ModalProps['styles'] & {
+        form?: FormProps['style'];
+    };
+    submitButtonProps?: ButtonProps;
+    submitLoading?: ModalProps['confirmLoading'];
+    submitText?: ModalProps['okText'];
+}
+
+declare const FormModal: react.NamedExoticComponent<FormModalProps>;
+
+interface GridProps extends Omit<FlexboxProps, 'gap'> {
+    gap?: string | number;
+    maxItemWidth?: string | number;
+    ref?: Ref<HTMLDivElement>;
+    rows?: number;
+}
+
+declare const Grid: FC<GridProps>;
+
+/**
+ * Predefined smooth corners masks for common corner values
+ */
+declare const SMOOTH_CORNER_MASKS: {
+    readonly circle: string;
+    readonly ios: string;
+    readonly sharp: string;
+    readonly smooth: string;
+    readonly square: string;
+    readonly squircle: string;
+};
+
+type AvatarItem = string | Omit<AvatarProps, 'size'>;
+interface GroupAvatarProps extends Omit<BlockProps, 'width' | 'height' | 'variant'> {
+    avatarShape?: AvatarProps['shape'];
+    avatars?: AvatarItem[];
+    cornerShape?: keyof typeof SMOOTH_CORNER_MASKS;
+    grid?: 2 | 3 | 'auto';
+    ref?: Ref<HTMLDivElement>;
+    size?: number;
+}
+
+declare const GroupAvatar: FC<GroupAvatarProps>;
+
+interface GuideCardProps extends Omit<FlexboxProps, 'title'> {
+    afterClose?: () => void;
+    alt?: string;
+    classNames?: {
+        content?: string;
+        cover?: string;
+    };
+    closable?: boolean;
+    closeIconProps?: Omit<ActionIconProps, 'icon' | 'onClick'>;
+    cover?: string;
+    coverProps?: ImgProps & ImageProps$2 & {
+        priority?: boolean;
+    };
+    desc?: ReactNode;
+    height?: number;
+    onClose?: ActionIconProps['onClick'];
+    ref?: Ref<HTMLDivElement>;
+    shadow?: boolean;
+    styles?: {
+        content?: CSSProperties;
+        cover?: CSSProperties;
+    };
+    title?: ReactNode;
+    variant?: 'filled' | 'outlined' | 'borderless';
+    width?: number;
+}
+
+declare const GuideCard: react.NamedExoticComponent<GuideCardProps>;
+
+interface HeaderProps extends FlexboxProps {
+    actions?: ReactNode;
+    actionsClassName?: string;
+    actionsStyle?: CSSProperties;
+    logo?: ReactNode;
+    logoClassName?: string;
+    logoStyle?: CSSProperties;
+    nav?: ReactNode;
+    navClassName?: string;
+    navStyle?: CSSProperties;
+    ref?: Ref<HTMLDivElement>;
+}
+
+declare const Header: react.NamedExoticComponent<HeaderProps>;
+
+interface HighlighterThemeItem {
+    displayName: string;
+    id: string;
+}
+declare const highlighterThemes: HighlighterThemeItem[];
+
+interface SyntaxHighlighterProps extends DivProps$1 {
+    animated?: boolean;
+    children: string;
+    enableTransformer?: HighlighterProps['enableTransformer'];
+    language: HighlighterProps['language'];
+    ref?: Ref<HTMLDivElement>;
+    theme?: HighlighterProps['theme'];
+    variant?: HighlighterProps['variant'];
+}
+interface HighlighterProps extends Omit<FlexboxProps, 'children' | 'wrap'> {
+    actionIconSize?: ActionIconProps['size'];
+    actionsRender?: (props: {
+        actionIconSize: ActionIconProps['size'];
+        content: string;
+        getContent: () => string;
+        language: string;
+        originalNode: ReactNode;
+    }) => ReactNode;
+    allowChangeLanguage?: boolean;
+    animated?: boolean;
+    bodyRender?: (props: {
+        content: string;
+        language: string;
+        originalNode: ReactNode;
+    }) => ReactNode;
+    children: string;
+    classNames?: {
+        body?: string;
+        content?: string;
+        header?: string;
+    };
+    copyable?: boolean;
+    defaultExpand?: boolean;
+    enableTransformer?: boolean;
+    fileName?: string;
+    fullFeatured?: boolean;
+    icon?: ReactNode;
+    language: string;
+    shadow?: boolean;
+    showLanguage?: boolean;
+    styles?: {
+        body?: CSSProperties;
+        content?: CSSProperties;
+        header?: CSSProperties;
+    };
+    theme?: 'lobe-theme' | BuiltinTheme;
+    variant?: 'filled' | 'outlined' | 'borderless';
+    wrap?: boolean;
+}
+
+declare const Highlighter: react.NamedExoticComponent<HighlighterProps>;
+
+declare const SyntaxHighlighter: react.NamedExoticComponent<SyntaxHighlighterProps>;
+
+/**
+ * Preprocessing options for markdown content
+ */
+interface PreprocessOptions {
+    citationsLength?: number;
+    enableCustomFootnotes?: boolean;
+    enableLatex?: boolean;
+}
+declare const preprocessMarkdownContent: (str: string, { enableCustomFootnotes, enableLatex, citationsLength }?: PreprocessOptions) => string;
+
+interface HotkeyInputProps {
+    allowReset?: boolean;
+    className?: string;
+    defaultValue?: string;
+    disabled?: boolean;
+    hotkeyConflicts?: string[];
+    isApple?: boolean;
+    onBlur?: InputProps$1['onBlur'];
+    onChange?: (value: string) => void;
+    onConflict?: (conflictKey: string) => void;
+    onFocus?: InputProps$1['onFocus'];
+    onReset?: (currentValue: string, resetValue: string) => void;
+    placeholder?: string;
+    resetValue?: string;
+    shadow?: boolean;
+    style?: CSSProperties;
+    texts?: {
+        conflicts?: string;
+        invalidCombination?: string;
+        reset?: string;
+    };
+    value?: string;
+    variant?: 'filled' | 'borderless' | 'outlined';
+}
+
+declare const HotkeyInput: react.NamedExoticComponent<HotkeyInputProps>;
+
+interface PreviewGroupPreviewOptions extends GroupPreviewConfig {
+    toolbarAddon?: ReactNode;
+}
+interface PreviewGroupProps {
+    children?: ReactNode;
+    enable?: boolean;
+    items?: string[];
+    preview?: boolean | PreviewGroupPreviewOptions;
+}
+interface ImagePreviewOptions extends PreviewConfig {
+    toolbarAddon?: ReactNode;
+}
+interface ImageProps$1 extends Omit<ImageProps$2, 'preview'> {
+    actions?: ReactNode;
+    alwaysShowActions?: boolean;
+    classNames?: {
+        image?: string;
+        wrapper?: string;
+    };
+    isLoading?: boolean;
+    maxHeight?: number | string;
+    maxWidth?: number | string;
+    minHeight?: number | string;
+    minWidth?: number | string;
+    objectFit?: 'cover' | 'contain';
+    preview?: boolean | ImagePreviewOptions;
+    ref?: Ref<HTMLDivElement>;
+    size?: number | string;
+    styles?: {
+        image?: CSSProperties;
+        wrapper?: CSSProperties;
+    };
+    toolbarAddon?: ReactNode;
+    variant?: 'borderless' | 'filled' | 'outlined';
+}
+
+declare const PreviewGroup: react.NamedExoticComponent<PreviewGroupProps>;
+
+interface IImage {
+    (props: ImageProps$1): ReactNode;
+    PreviewGroup: typeof PreviewGroup;
+}
+declare const Image: IImage;
+
+interface ImageSelectItem {
+    alt?: string;
+    icon?: IconProps$1['icon'];
+    img: string;
+    label: ReactNode;
+    value: string;
+}
+interface ImageSelectProps extends FlexboxProps {
+    className?: string;
+    classNames?: {
+        img?: string;
+    };
+    defaultValue?: SelectProps$1['defaultValue'];
+    height?: number;
+    onChange?: (value: this['value']) => void;
+    options?: ImageSelectItem[];
+    ref?: Ref<HTMLDivElement>;
+    style?: CSSProperties;
+    styles?: {
+        img?: CSSProperties;
+    };
+    unoptimized?: boolean;
+    value?: SelectProps$1['value'];
+    width?: number;
+}
+
+declare const ImageSelect: react.NamedExoticComponent<ImageSelectProps>;
+
+declare const LayoutFooter: react.NamedExoticComponent<DivProps$1>;
+
+interface LayoutProps {
+    asideWidth?: number;
+    children?: ReactNode;
+    content?: ReactNode;
+    footer?: ReactNode;
+    header?: ReactNode;
+    headerHeight?: number;
+    helmet?: ReactNode;
+    sidebar?: ReactNode;
+    toc?: ReactNode;
+    tocWidth?: number;
+}
+type LayoutFooterProps = DivProps$1;
+interface LayoutHeaderProps extends DivProps$1 {
+    headerHeight?: number;
+}
+type LayoutMainProps = DivProps$1;
+interface LayoutSidebarProps extends DivProps$1 {
+    headerHeight?: number;
+}
+interface LayoutSidebarInnerProps extends DivProps$1 {
+    headerHeight?: number;
+}
+interface LayoutTocProps extends DivProps$1 {
+    tocWidth?: number;
+}
+
+declare const LayoutHeader: react.NamedExoticComponent<LayoutHeaderProps>;
+
+declare const LayoutMain: react.NamedExoticComponent<DivProps$1>;
+
+declare const LayoutSidebar: react.NamedExoticComponent<LayoutSidebarProps>;
+
+declare const LayoutSidebarInner: react.NamedExoticComponent<LayoutSidebarInnerProps>;
+
+declare const LayoutToc: react.NamedExoticComponent<LayoutTocProps>;
+
+interface ILayout {
+    (props: LayoutProps): ReactNode;
+    Footer: typeof LayoutFooter;
+    Header: typeof LayoutHeader;
+    Main: typeof LayoutMain;
+    Sidebar: typeof LayoutSidebar;
+    SidebarInner: typeof LayoutSidebarInner;
+    Toc: typeof LayoutToc;
+}
+declare const Layout: ILayout;
+
+interface ListItemProps extends Omit<FlexboxProps, 'title'> {
+    actions?: ReactNode;
+    active?: boolean;
+    addon?: ReactNode;
+    avatar?: ReactNode;
+    classNames?: {
+        actions?: string;
+        container?: string;
+        content?: string;
+        date?: string;
+        desc?: string;
+        pin?: string;
+        title?: string;
+    };
+    date?: number;
+    description?: ReactNode;
+    key: string;
+    loading?: boolean;
+    onHoverChange?: (hover: boolean) => void;
+    pin?: boolean;
+    ref?: Ref<HTMLDivElement>;
+    showAction?: boolean;
+    styles?: {
+        actions?: CSSProperties;
+        container?: CSSProperties;
+        content?: CSSProperties;
+        date?: CSSProperties;
+        desc?: CSSProperties;
+        pin?: CSSProperties;
+        title?: CSSProperties;
+    };
+    title: ReactNode;
+}
+interface ListProps extends Omit<FlexboxProps, 'onClick'> {
+    activeKey?: string;
+    classNames?: {
+        item?: string;
+    } & ListItemProps['classNames'];
+    items: ListItemProps[];
+    onClick?: (props: {
+        item: ListItemProps;
+        key: ListItemProps['key'];
+    }) => void;
+    ref?: Ref<HTMLDivElement>;
+    styles?: {
+        item?: CSSProperties;
+    } & ListItemProps['styles'];
+}
+
+declare const ListItem: react.NamedExoticComponent<ListItemProps>;
+
+interface IList {
+    (props: ListProps & RefAttributes<HTMLDivElement>): ReactNode;
+    Item: typeof ListItem;
+}
+declare const List: IList;
+
+type LobeSelectSize = 'large' | 'middle' | 'small';
+type LobeSelectVariant = 'borderless' | 'filled' | 'outlined';
+type LobeSelectBehaviorVariant = 'default' | 'item-aligned';
+/**
+ * Variant for how selected items are indicated in the popup.
+ * - `check`: Display a checkmark icon next to selected items (default)
+ * - `bold`: Display selected items with bold text, no checkmark
+ */
+type LobeSelectIndicatorVariant = 'check' | 'bold';
+interface LobeSelectOption<Value = string> {
+    className?: string;
+    disabled?: boolean;
+    label: ReactNode;
+    style?: CSSProperties;
+    title?: string;
+    value: Value;
+}
+interface LobeSelectOptionGroup<Value = string> {
+    disabled?: boolean;
+    label: ReactNode;
+    options: LobeSelectOption<Value>[];
+}
+type LobeSelectOptions<Value = string> = Array<LobeSelectOption<Value> | LobeSelectOptionGroup<Value>>;
+interface LobeSelectClassNames {
+    clear?: string;
+    dropdown?: string;
+    empty?: string;
+    group?: string;
+    groupLabel?: string;
+    icon?: string;
+    item?: string;
+    itemIndicator?: string;
+    itemText?: string;
+    list?: string;
+    option?: string;
+    popup?: string;
+    prefix?: string;
+    root?: string;
+    search?: string;
+    suffix?: string;
+    trigger?: string;
+    value?: string;
+}
+interface LobeSelectProps<Value = string> {
+    allowClear?: boolean;
+    autoFocus?: boolean;
+    /**
+     * Behavior variant for Base UI Select.
+     *
+     * - `default`: regular dropdown positioning (alignItemWithTrigger=false, modal=false)
+     * - `item-aligned`: aligns the selected item with trigger and uses modal=true
+     * @default 'default'
+     */
+    behaviorVariant?: LobeSelectBehaviorVariant;
+    className?: string;
+    classNames?: LobeSelectClassNames;
+    defaultOpen?: boolean;
+    defaultValue?: Value | Value[] | null;
+    disabled?: boolean;
+    id?: string;
+    labelRender?: (option: LobeSelectOption<Value>) => ReactNode;
+    /**
+     * 设置弹窗滚动高度
+     * @default 256
+     */
+    listHeight?: number;
+    listItemHeight?: number;
+    loading?: boolean;
+    mode?: 'multiple' | 'tags';
+    name?: string;
+    onChange?: (value: Value | Value[] | null, option?: LobeSelectOption<Value> | LobeSelectOption<Value>[]) => void;
+    onOpenChange?: (open: boolean) => void;
+    onSelect?: (value: Value, option?: LobeSelectOption<Value>) => void;
+    open?: boolean;
+    optionRender?: (option: LobeSelectOption<Value>, info: {
+        index: number;
+    }) => ReactNode;
+    options?: LobeSelectOptions<Value>;
+    placeholder?: ReactNode;
+    popupClassName?: string;
+    popupMatchSelectWidth?: boolean | number;
+    prefix?: ReactNode | IconProps$1['icon'];
+    readOnly?: boolean;
+    required?: boolean;
+    /**
+     * Variant for how selected items are indicated in the popup.
+     * - `check`: Display a checkmark icon next to selected items (default)
+     * - `bold`: Display selected items with bold text, no checkmark
+     * @default 'check'
+     */
+    selectedIndicatorVariant?: LobeSelectIndicatorVariant;
+    shadow?: boolean;
+    showSearch?: boolean;
+    size?: LobeSelectSize;
+    style?: CSSProperties;
+    suffixIcon?: IconProps$1['icon'] | ReactNode;
+    suffixIconProps?: Omit<IconProps$1, 'icon'>;
+    tokenSeparators?: string[];
+    value?: Value | Value[] | null;
+    variant?: LobeSelectVariant;
+    virtual?: boolean;
+}
+
+declare const LOBE_SELECT_CONTAINER_ATTR = "data-lobe-ui-select-container";
+
+declare const LobeSelectRoot: typeof Select$1.Root;
+declare const LobeSelectBackdrop: react.ForwardRefExoticComponent<_base_ui_react_select.SelectBackdropProps & react.RefAttributes<HTMLDivElement>>;
+declare const LobeSelectSeparator: react.ForwardRefExoticComponent<node_modules__base_ui_react_esm_separator_Separator.SeparatorProps & react.RefAttributes<HTMLDivElement>>;
+type LobeSelectTriggerProps = Omit<ComponentPropsWithRef<typeof Select$1.Trigger>, 'children' | 'render'> & {
+    children: ComponentProps<typeof Select$1.Trigger>['children'];
+    shadow?: boolean;
+    size?: LobeSelectSize;
+    variant?: LobeSelectVariant;
+};
+declare const LobeSelectTrigger: {
+    ({ children, className, nativeButton, shadow, size, variant, ref: refProp, ...rest }: LobeSelectTriggerProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type LobeSelectIconProps = ComponentProps<typeof Select$1.Icon>;
+declare const LobeSelectIcon: {
+    ({ className, ...rest }: LobeSelectIconProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type LobeSelectValueProps = ComponentProps<typeof Select$1.Value>;
+declare const LobeSelectValue: {
+    ({ className, ...rest }: LobeSelectValueProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type LobeSelectPortalProps = ComponentProps<typeof Select$1.Portal> & {
+    /**
+     * When `container` is not provided, it uses a shared container created by `usePortalContainer`.
+     */
+    container?: HTMLElement | null;
+};
+declare const LobeSelectPortal: {
+    ({ container, ...rest }: LobeSelectPortalProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type LobeSelectPositionerProps = ComponentProps<typeof Select$1.Positioner>;
+declare const LobeSelectPositioner: {
+    ({ align, alignItemWithTrigger, className, side, sideOffset, ...rest }: LobeSelectPositionerProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type LobeSelectPopupProps = ComponentProps<typeof Select$1.Popup>;
+declare const LobeSelectPopup: {
+    ({ className, ...rest }: LobeSelectPopupProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type LobeSelectListProps = ComponentProps<typeof Select$1.List>;
+declare const LobeSelectList: {
+    ({ className, ...rest }: LobeSelectListProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type LobeSelectItemProps = ComponentProps<typeof Select$1.Item>;
+declare const LobeSelectItem: {
+    ({ className, ...rest }: LobeSelectItemProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type LobeSelectItemTextProps = ComponentProps<typeof Select$1.ItemText>;
+declare const LobeSelectItemText: {
+    ({ className, ...rest }: LobeSelectItemTextProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type LobeSelectItemIndicatorProps = ComponentProps<typeof Select$1.ItemIndicator>;
+declare const LobeSelectItemIndicator: {
+    ({ className, ...rest }: LobeSelectItemIndicatorProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type LobeSelectGroupProps = ComponentProps<typeof Select$1.Group>;
+declare const LobeSelectGroup: {
+    ({ className, ...rest }: LobeSelectGroupProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type LobeSelectGroupLabelProps = ComponentProps<typeof Select$1.GroupLabel>;
+declare const LobeSelectGroupLabel: {
+    ({ className, ...rest }: LobeSelectGroupLabelProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type LobeSelectScrollUpArrowProps = ComponentProps<typeof Select$1.ScrollUpArrow>;
+declare const LobeSelectScrollUpArrow: {
+    ({ className, ...rest }: LobeSelectScrollUpArrowProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type LobeSelectScrollDownArrowProps = ComponentProps<typeof Select$1.ScrollDownArrow>;
+declare const LobeSelectScrollDownArrow: {
+    ({ className, ...rest }: LobeSelectScrollDownArrowProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type LobeSelectArrowProps = ComponentProps<typeof Select$1.Arrow>;
+declare const LobeSelectArrow: {
+    ({ className, ...rest }: LobeSelectArrowProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+declare const LobeSelect: react.NamedExoticComponent<LobeSelectProps<any>>;
+
+type LobeSwitchSize = 'default' | 'small';
+type LobeSwitchChangeEventHandler = (checked: boolean, event: MouseEvent<HTMLButtonElement> | KeyboardEvent<HTMLButtonElement>) => void;
+type LobeSwitchClickEventHandler = LobeSwitchChangeEventHandler;
+interface LobeSwitchClassNames {
+    content?: string;
+    root?: string;
+    thumb?: string;
+}
+interface LobeSwitchStyles {
+    content?: CSSProperties;
+    root?: CSSProperties;
+    thumb?: CSSProperties;
+}
+interface LobeSwitchContextType {
+    isChecked: boolean;
+    isPressed: boolean;
+    setIsChecked: (checked: boolean) => void;
+    setIsPressed: (pressed: boolean) => void;
+}
+type LobeSwitchRootProps = Omit<ComponentProps<typeof Switch.Root>, 'render'> & HTMLMotionProps<'button'> & {
+    size?: LobeSwitchSize;
+};
+type LobeSwitchThumbProps = Omit<ComponentProps<typeof Switch.Thumb>, 'render'> & HTMLMotionProps<'span'> & {
+    pressedAnimation?: TargetAndTransition | boolean;
+    size?: LobeSwitchSize;
+    transition?: Transition;
+};
+type LobeSwitchIconPosition = 'left' | 'right' | 'thumb';
+type LobeSwitchIconProps = HTMLMotionProps<'span'> & {
+    position: LobeSwitchIconPosition;
+    transition?: Transition;
+};
+interface LobeSwitchProps {
+    /**
+     * Whether to set focus automatically when mounted
+     */
+    autoFocus?: boolean;
+    /**
+     * Whether the switch is checked
+     */
+    checked?: boolean;
+    /**
+     * Icon to show when checked (left position)
+     */
+    checkedChildren?: ReactNode;
+    /**
+     * Custom class name
+     */
+    className?: string;
+    /**
+     * Custom class names for each part
+     */
+    classNames?: LobeSwitchClassNames;
+    /**
+     * Initial checked state (uncontrolled)
+     */
+    defaultChecked?: boolean;
+    /**
+     * Alias for `defaultChecked`
+     */
+    defaultValue?: boolean;
+    /**
+     * Whether the switch is disabled
+     */
+    disabled?: boolean;
+    /**
+     * Element id
+     */
+    id?: string;
+    /**
+     * Show loading indicator
+     */
+    loading?: boolean;
+    /**
+     * Name attribute for form submission
+     */
+    name?: string;
+    /**
+     * Callback when the switch state changes
+     */
+    onChange?: LobeSwitchChangeEventHandler;
+    /**
+     * Callback when clicking the switch
+     */
+    onClick?: LobeSwitchClickEventHandler;
+    /**
+     * Reference to the root element
+     */
+    ref?: Ref<HTMLButtonElement>;
+    /**
+     * Additional class name for root element
+     */
+    rootClassName?: string;
+    /**
+     * Size of the switch
+     * @default 'default'
+     */
+    size?: LobeSwitchSize;
+    /**
+     * Custom inline style
+     */
+    style?: CSSProperties;
+    /**
+     * Custom styles for each part
+     */
+    styles?: LobeSwitchStyles;
+    /**
+     * Tab index for keyboard navigation
+     */
+    tabIndex?: number;
+    /**
+     * Native title attribute
+     */
+    title?: string;
+    /**
+     * Icon to show when unchecked (right position)
+     */
+    unCheckedChildren?: ReactNode;
+    /**
+     * Alias for `checked`
+     */
+    value?: boolean;
+}
+
+declare const styles$1: {
+    icon: string;
+    iconLeft: string;
+    iconLeftSmall: string;
+    iconRight: string;
+    iconRightSmall: string;
+    iconThumb: string;
+    loading: string;
+    root: string;
+    rootDefault: string;
+    rootSmall: string;
+    thumb: string;
+    thumbDefault: string;
+    thumbSmall: string;
+};
+
+declare const useLobeSwitchContext: () => LobeSwitchContextType;
+type LobeSwitchRootInternalProps = Omit<LobeSwitchRootProps, 'onCheckedChange' | 'onClick'> & {
+    onCheckedChange?: LobeSwitchChangeEventHandler;
+    onClick?: LobeSwitchChangeEventHandler;
+};
+declare const LobeSwitchRoot: {
+    ({ checked, className, defaultChecked, onCheckedChange, onClick, size, children, disabled, readOnly, required, inputRef, id, name, ...rest }: LobeSwitchRootInternalProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const LobeSwitchThumb: {
+    ({ className, pressedAnimation, size, transition, children, ...rest }: LobeSwitchThumbProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const LobeSwitchIcon: {
+    ({ children, className, position, transition, ...rest }: LobeSwitchIconProps & {
+        children?: React.ReactNode;
+        size?: "default" | "small";
+    }): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+declare const LobeSwitch: react.NamedExoticComponent<LobeSwitchProps>;
+
+interface MermaidThemeItem {
+    background?: string;
+    displayName: string;
+    id: string;
+}
+declare const mermaidThemes: MermaidThemeItem[];
+
+interface SyntaxMermaidProps {
+    animated?: boolean;
+    children: string;
+    className?: string;
+    fallbackClassName?: string;
+    ref?: Ref<HTMLDivElement>;
+    style?: CSSProperties;
+    theme?: MermaidProps['theme'];
+    variant?: MermaidProps['variant'];
+}
+interface MermaidProps extends DivProps$1 {
+    actionIconSize?: ActionIconProps['size'];
+    actionsRender?: (props: {
+        actionIconSize: ActionIconProps['size'];
+        content: string;
+        getContent: () => string;
+        originalNode: ReactNode;
+    }) => ReactNode;
+    animated?: boolean;
+    bodyRender?: (props: {
+        content: string;
+        originalNode: ReactNode;
+    }) => ReactNode;
+    children: string;
+    classNames?: {
+        body?: string;
+        content?: string;
+        header?: string;
+    };
+    copyable?: boolean;
+    defaultExpand?: boolean;
+    fileName?: string;
+    fullFeatured?: boolean;
+    language?: string;
+    shadow?: boolean;
+    showLanguage?: boolean;
+    styles?: {
+        body?: CSSProperties;
+        content?: CSSProperties;
+        header?: CSSProperties;
+    };
+    theme?: 'lobe-theme' | MermaidConfig['theme'];
+    variant?: 'filled' | 'outlined' | 'borderless';
+}
+
+declare const Mermaid: react.NamedExoticComponent<MermaidProps>;
+
+declare const SyntaxMermaid: react.NamedExoticComponent<SyntaxMermaidProps>;
+
+type ImageProps = ImageProps$1;
+
+interface CitationItem {
+    alt?: string;
+    summary?: string;
+    title?: string;
+    url: string;
+}
+
+interface SnippetProps extends FlexboxProps {
+    children: string;
+    copyable?: boolean;
+    language?: string;
+    prefix?: string;
+    ref?: Ref<HTMLDivElement>;
+    shadow?: boolean;
+    spotlight?: boolean;
+    variant?: 'filled' | 'outlined' | 'borderless';
+}
+
+declare const Snippet: FC<SnippetProps>;
+
+type PreProps = HighlighterProps;
+
+interface VideoProps$1 extends VideoProps$2, Pick<FlexboxProps, 'width' | 'height'> {
+    autoPlay?: boolean;
+    classNames?: {
+        mask?: string;
+        video?: string;
+        wrapper?: string;
+    };
+    isLoading?: boolean;
+    loop?: boolean;
+    maxHeight?: number | string;
+    maxWidth?: number | string;
+    minHeight?: number | string;
+    minWidth?: number | string;
+    muted?: HTMLVideoElement['muted'];
+    onEnded?: VideoProps$2['onEnded'];
+    onMouseEnter?: VideoProps$2['onMouseEnter'];
+    onMouseLeave?: VideoProps$2['onMouseLeave'];
+    onPause?: VideoProps$2['onPause'];
+    onPlay?: VideoProps$2['onPlay'];
+    onPlaying?: VideoProps$2['onPlaying'];
+    onProgress?: VideoProps$2['onProgress'];
+    poster?: string;
+    preload?: HTMLVideoElement['preload'];
+    preview?: boolean;
+    ref?: Ref<HTMLDivElement>;
+    size?: number | string;
+    src: string;
+    styles?: {
+        mask?: CSSProperties;
+        video?: CSSProperties;
+        wrapper?: CSSProperties;
+    };
+    variant?: 'borderless' | 'filled' | 'outlined';
+}
+declare const Video: react.NamedExoticComponent<VideoProps$1>;
+
+type VideoProps = VideoProps$1;
+
+interface TabsProps extends TabsProps$1 {
+    compact?: boolean;
+    variant?: 'square' | 'rounded' | 'point';
+}
+
+declare const Tabs: FC<TabsProps>;
+
+interface TypographyProps extends DivProps$1 {
+    borderRadius?: number;
+    fontSize?: number;
+    headerMultiple?: number;
+    lineHeight?: number;
+    marginMultiple?: number;
+    ref?: Ref<HTMLDivElement>;
+}
+interface SyntaxMarkdownProps {
+    allowHtml?: boolean;
+    allowHtmlList?: ElementType[];
+    animated?: boolean;
+    children: string;
+    citations?: CitationItem[];
+    componentProps?: {
+        a?: Partial<AProps & AnchorProps>;
+        highlight?: Partial<HighlighterProps>;
+        img?: Partial<ImageProps>;
+        mermaid?: Partial<MermaidProps>;
+        pre?: Partial<PreProps>;
+        video?: Partial<VideoProps>;
+    };
+    components?: Components & Record<string, FC>;
+    enableCustomFootnotes?: boolean;
+    enableGithubAlert?: boolean;
+    enableLatex?: boolean;
+    enableMermaid?: boolean;
+    enableStream?: boolean;
+    fullFeaturedCodeBlock?: boolean;
+    reactMarkdownProps?: Omit<Readonly<Options>, 'components' | 'rehypePlugins' | 'remarkPlugins'>;
+    rehypePlugins?: Pluggable[];
+    rehypePluginsAhead?: Pluggable[];
+    remarkPlugins?: Pluggable[];
+    remarkPluginsAhead?: Pluggable[];
+    showFootnotes?: boolean;
+    variant?: 'default' | 'chat';
+}
+interface MarkdownProps extends SyntaxMarkdownProps, Omit<TypographyProps, 'children'> {
+    className?: string;
+    customRender?: (dom: ReactNode, context: {
+        text: string;
+    }) => ReactNode;
+    enableImageGallery?: boolean;
+    onDoubleClick?: () => void;
+    ref?: Ref<HTMLDivElement>;
+    style?: CSSProperties;
+}
+
+declare const Markdown: react.NamedExoticComponent<MarkdownProps>;
+
+declare const Typography: react.NamedExoticComponent<TypographyProps>;
+
+interface SearchResultItem {
+    alt?: string;
+    summary?: string;
+    title?: string;
+    url: string;
+}
+interface SearchResultCardsProps extends FlexboxProps {
+    dataSource: string[] | SearchResultItem[];
+    ref?: Ref<HTMLDivElement>;
+}
+declare const SearchResultCards: react.NamedExoticComponent<SearchResultCardsProps>;
+
+declare const rehypeCustomFootnotes: () => (tree: any, file: any) => void;
+
+declare const rehypeKatexDir: () => (tree: Node) => void;
+
+declare const rehypeStreamAnimated: () => (tree: Root) => void;
+
+/**
+ * Remark plugin to handle <br> and <br/> tags in markdown text
+ * This plugin converts <br> and <br/> tags to proper HTML elements
+ * without requiring allowHtml to be enabled
+ */
+declare const remarkBr: () => (tree: any) => void;
+
+interface RemarkColorOptions {
+    /**
+     * 自定义颜色验证函数
+     */
+    colorValidator?: (colorString: string) => boolean;
+}
+/**
+ * Remark plugin to handle color syntax in markdown code spans
+ * Supports GitHub-style color visualization for HEX, RGB, and HSL colors
+ *
+ * @example
+ * `#FF0000` -> renders with red color preview
+ * `rgb(255, 0, 0)` -> renders with red color preview
+ * `hsl(0, 100%, 50%)` -> renders with red color preview
+ */
+declare const remarkColor: (options?: RemarkColorOptions) => (tree: any) => void;
+
+declare const remarkCustomFootnotes: () => (tree: any, file: any) => void;
+
+interface RemarkGfmPlusOptions {
+    allowHtmlTags?: string[];
+}
+declare const remarkGfmPlus: (options?: RemarkGfmPlusOptions) => (tree: any) => void;
+
+interface RemarkVideoOptions {
+    /**
+     * 支持的视频标签名，默认为 ['video']
+     */
+    videoTags?: string[];
+}
+/**
+ * Remark plugin to handle <video> tags in markdown text
+ * This plugin converts <video> tags to proper video elements
+ * without requiring allowHtml to be enabled
+ *
+ * @example
+ * <video src="https://example.com/video.mp4" />
+ * <video src="https://example.com/video.mp4" controls width="400" height="300" />
+ */
+declare const remarkVideo: (options?: RemarkVideoOptions) => (tree: any) => void;
+
+interface MaskShadowProps extends FlexboxProps {
+    position?: 'top' | 'bottom' | 'left' | 'right';
+    size?: number;
+    visibility?: 'auto' | 'always' | 'never';
+}
+
+declare const MaskShadow: react.NamedExoticComponent<MaskShadowProps>;
+
+interface MaterialFileTypeIconProps extends DivProps$1 {
+    fallbackUnknownType?: boolean;
+    filename: string;
+    open?: boolean;
+    size?: number;
+    type?: 'file' | 'folder';
+    variant?: 'raw' | 'file' | 'folder';
+}
+
+declare const MaterialFileTypeIcon: FC<MaterialFileTypeIconProps>;
+
+declare const styles: {
+    danger: string;
+    empty: string;
+    extra: string;
+    groupLabel: string;
+    icon: string;
+    item: string;
+    itemContent: string;
+    label: string;
+    popup: string;
+    positioner: string;
+    separator: string;
+    submenuArrow: string;
+};
+
+interface I18nProviderProps {
+    children: ReactNode;
+    locale?: string;
+    motion: MotionComponentType;
+    resources?: TranslationResourcesInput;
+}
+
+declare const I18nProvider: react.NamedExoticComponent<I18nProviderProps>;
+
+declare const useTranslation: (fallbackResources?: TranslationResources) => {
+    locale: string;
+    t: (key: TranslationKey) => string;
+};
+
+type ScrollAreaRootProps = react__default.ComponentProps<typeof ScrollArea$1.Root>;
+type ScrollAreaViewportProps = react__default.ComponentProps<typeof ScrollArea$1.Viewport> & {
+    /**
+     * Enable gradient scroll fade on the viewport edges.
+     * @default false
+     */
+    scrollFade?: boolean;
+};
+type ScrollAreaContentProps = react__default.ComponentProps<typeof ScrollArea$1.Content>;
+type ScrollAreaScrollbarProps = react__default.ComponentProps<typeof ScrollArea$1.Scrollbar>;
+type ScrollAreaThumbProps = react__default.ComponentProps<typeof ScrollArea$1.Thumb>;
+type ScrollAreaCornerProps = react__default.ComponentProps<typeof ScrollArea$1.Corner>;
+declare const ScrollAreaRoot: {
+    ({ className, ...rest }: ScrollAreaRootProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const ScrollAreaViewport: {
+    ({ className, scrollFade, ...rest }: ScrollAreaViewportProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const ScrollAreaContent: {
+    ({ className, ...rest }: ScrollAreaContentProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const ScrollAreaScrollbar: {
+    ({ className, ...rest }: ScrollAreaScrollbarProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const ScrollAreaThumb: {
+    ({ className, ...rest }: ScrollAreaThumbProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const ScrollAreaCorner: {
+    ({ className, ...rest }: ScrollAreaCornerProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+interface ScrollAreaProps extends Omit<ScrollAreaRootProps, 'children'> {
+    children?: ReactNode;
+    contentProps?: Omit<ScrollAreaContentProps, 'children'>;
+    corner?: boolean;
+    cornerProps?: ScrollAreaCornerProps;
+    scrollFade?: boolean;
+    scrollbarProps?: Omit<ScrollAreaScrollbarProps, 'children'>;
+    thumbProps?: ScrollAreaThumbProps;
+    viewportProps?: Omit<ScrollAreaViewportProps, 'children' | 'scrollFade'>;
+}
+
+declare const ScrollArea: FC<ScrollAreaProps>;
+
+interface ScrollShadowProps extends FlexboxProps {
+    hideScrollBar?: boolean;
+    isEnabled?: boolean;
+    offset?: number;
+    onVisibilityChange?: (visibility: {
+        bottom?: boolean;
+        left?: boolean;
+        right?: boolean;
+        top?: boolean;
+    }) => void;
+    orientation?: 'vertical' | 'horizontal';
+    ref?: Ref<HTMLDivElement>;
+    size?: number;
+    visibility?: 'auto' | 'always' | 'never';
+}
+
+declare const ScrollShadow: FC<ScrollShadowProps>;
+
+interface SearchBarProps extends Omit<InputProps, 'styles' | 'classNames'> {
+    classNames?: {
+        input?: string;
+        shortKey?: string;
+    };
+    defaultValue?: string;
+    enableShortKey?: boolean;
+    loading?: boolean;
+    onInputChange?: (value: string) => void;
+    onSearch?: (value: string) => void;
+    shortKey?: string;
+    spotlight?: boolean;
+    styles?: {
+        input?: CSSProperties;
+        shortKey?: CSSProperties;
+    };
+    value?: string;
+}
+
+declare const SearchBar: react.NamedExoticComponent<SearchBarProps>;
+
+interface SegmentedProps extends SegmentedProps$1 {
+    glass?: boolean;
+    iconProps?: Omit<IconProps$1, 'icon'>;
+    padding?: string | number;
+    ref?: Ref<HTMLDivElement>;
+    shadow?: boolean;
+    variant?: 'filled' | 'outlined' | 'borderless';
+}
+
+declare const Segmented: react.NamedExoticComponent<SegmentedProps>;
+
+interface SelectProps extends Omit<SelectProps$1, 'suffixIcon'> {
+    ref?: Ref<RefSelectProps>;
+    shadow?: boolean;
+    suffixIcon?: IconProps$1['icon'];
+    suffixIconProps?: Omit<IconProps$1, 'icon'>;
+}
+
+/**
+ * @deprecated Use `LobeSelect` instead.
+ */
+declare const Select: react.NamedExoticComponent<SelectProps>;
+
+interface SideNavProps extends FlexboxProps {
+    avatar?: ReactNode;
+    bottomActions: ReactNode;
+    topActions?: ReactNode;
+}
+
+declare const SideNav: react.NamedExoticComponent<SideNavProps>;
+
+interface SkeletonBlockProps {
+    active?: boolean;
+    className?: string;
+    height?: number | string;
+    style?: CSSProperties;
+    width?: number | string;
+}
+interface SkeletonTitleProps extends Omit<SkeletonBlockProps, 'height'> {
+    fontSize?: number;
+    height?: number;
+    lineHeight?: number;
+    width?: number | string;
+}
+interface SkeletonParagraphProps extends Omit<SkeletonBlockProps, 'width' | 'height'> {
+    fontSize?: number;
+    gap?: number;
+    height?: number;
+    lineHeight?: number;
+    rows?: number;
+    width?: number | string | (number | string)[];
+}
+interface SkeletonTagsProps extends Omit<SkeletonBlockProps, 'width'> {
+    count?: number;
+    gap?: number;
+    size?: 'small' | 'middle' | 'large';
+    width?: number | string | (number | string)[];
+}
+interface SkeletonAvatarProps extends SkeletonBlockProps {
+    shape?: 'circle' | 'square';
+    size?: number | string;
+}
+interface SkeletonButtonProps extends SkeletonBlockProps {
+    block?: boolean;
+    shape?: 'circle' | 'round' | 'default';
+    size?: 'large' | 'small' | 'default';
+}
+interface SkeletonProps extends SkeletonBlockProps {
+    avatar?: SkeletonAvatarProps | boolean;
+    classNames?: {
+        avatar?: string;
+        paragraph?: string;
+        root?: string;
+        title?: string;
+    };
+    gap?: number;
+    paragraph?: SkeletonParagraphProps | boolean;
+    styles?: {
+        avatar?: CSSProperties;
+        paragraph?: CSSProperties;
+        root?: CSSProperties;
+        title?: CSSProperties;
+    };
+    title?: SkeletonTitleProps | boolean;
+}
+
+declare const SkeletonAvatar: FC<SkeletonAvatarProps>;
+
+declare const SkeletonBlock: FC<SkeletonBlockProps>;
+
+declare const SkeletonButton: FC<SkeletonButtonProps>;
+
+declare const SkeletonParagraph: FC<SkeletonParagraphProps>;
+
+declare const SkeletonTags: FC<SkeletonTagsProps>;
+
+declare const SkeletonTitle: FC<SkeletonTitleProps>;
+
+interface ISkeleton {
+    (props: SkeletonProps): ReactNode;
+    Avatar: typeof SkeletonAvatar;
+    Block: typeof SkeletonBlock;
+    Button: typeof SkeletonButton;
+    Paragraph: typeof SkeletonParagraph;
+    Tags: typeof SkeletonTags;
+    Title: typeof SkeletonTitle;
+}
+declare const Skeleton: ISkeleton;
+
+interface SliderWithInputProps extends Omit<SliderSingleProps, 'classNames' | 'styles'> {
+    changeOnWheel?: boolean;
+    classNames?: {
+        input?: string;
+        slider?: string;
+    } & SliderSingleProps['classNames'];
+    controls?: InputNumberProps['controls'];
+    gap?: FlexboxProps['gap'];
+    size?: InputNumberProps['size'];
+    styles?: {
+        input?: CSSProperties;
+        slider?: CSSProperties;
+    } & SliderSingleProps['styles'];
+    unlimitedInput?: boolean;
+    variant?: InputNumberProps['variant'];
+}
+
+declare const SliderWithInput: react.NamedExoticComponent<SliderWithInputProps>;
+
+declare const DragHandle: react.NamedExoticComponent<ActionIconProps>;
+
+interface SortableItemProps extends Omit<FlexboxProps, 'id'> {
+    id: string | number;
+    variant?: 'borderless' | 'filled' | 'outlined';
+}
+declare const SortableItem: react.NamedExoticComponent<SortableItemProps>;
+
+interface SortableListItem {
+    [key: string]: any;
+    id: string | number;
+}
+interface SortableListProps extends Omit<FlexboxProps, 'onChange'> {
+    items: SortableListItem[];
+    onChange(items: SortableListItem[]): void;
+    ref?: Ref<HTMLUListElement>;
+    renderItem(item: SortableListItem): ReactNode;
+}
+
+interface ISortableList {
+    (props: SortableListProps): ReactNode;
+    DragHandle: typeof DragHandle;
+    Item: typeof SortableItem;
+}
+declare const SortableList: ISortableList;
+
+declare const primaryColors: {
+    blue: string;
+    cyan: string;
+    geekblue: string;
+    gold: string;
+    green: string;
+    lime: string;
+    magenta: string;
+    orange: string;
+    purple: string;
+    red: string;
+    volcano: string;
+    yellow: string;
+};
+type PrimaryColorsObj = typeof primaryColors;
+type PrimaryColors = keyof PrimaryColorsObj;
+declare const primaryColorsSwatches: string[];
+declare const neutralColors: {
+    mauve: string;
+    olive: string;
+    sage: string;
+    sand: string;
+    slate: string;
+};
+declare const neutralColorsSwatches: string[];
+type NeutralColorsObj = typeof neutralColors;
+type NeutralColors = keyof NeutralColorsObj;
+declare const findCustomThemeName: (type: "primary" | "neutral", value: string) => string | undefined;
+
+declare const generateCustomStylish: GetCustomStylish<LobeCustomStylish>;
+
+declare const staticStylish: LobeCustomStylish;
+
+declare const generateCustomToken: GetCustomToken<LobeCustomToken>;
+
+type colorStep = [
+    string,
+    string,
+    string,
+    string,
+    string,
+    string,
+    string,
+    string,
+    string,
+    string,
+    string,
+    string,
+    string
+];
+interface ColorScaleItem {
+    dark: colorStep;
+    darkA: colorStep;
+    light: colorStep;
+    lightA: colorStep;
+}
+
+declare const generateColorPalette: ({ type, scale, appearance, }: {
+    appearance: "light" | "dark";
+    scale: ColorScaleItem;
+    type: "Primary" | "Success" | "Warning" | "Error" | "Info" | string;
+}) => Partial<AliasToken>;
+declare const generateColorNeutralPalette: ({ scale, appearance, }: {
+    appearance: "light" | "dark";
+    scale: ColorScaleItem;
+}) => Partial<AliasToken>;
+
+declare const CLASSNAMES: {
+    ContextTrigger: string;
+    DropdownMenuTrigger: string;
+};
+
+declare const LOBE_THEME_APP_ID = "lobe-ui-theme-app";
+
+interface ThemeProviderProps extends ThemeProviderProps$1<any> {
+    className?: string;
+    customFonts?: string[];
+    customStylish?: (theme: CustomStylishParams) => {
+        [key: string]: any;
+    };
+    customTheme?: {
+        neutralColor?: NeutralColors;
+        primaryColor?: PrimaryColors;
+    };
+    customToken?: (theme: CustomTokenParams) => {
+        [key: string]: any;
+    };
+    enableCustomFonts?: boolean;
+    enableGlobalStyle?: boolean;
+    style?: CSSProperties;
+}
+interface MetaProps {
+    description?: string;
+    title?: string;
+    withManifest?: boolean;
+}
+
+declare const Meta: FC<MetaProps>;
+
+declare const ThemeProvider: react.NamedExoticComponent<ThemeProviderProps>;
+
+interface ThemeSwitchProps extends DivProps$1 {
+    labels?: {
+        auto: string;
+        dark: string;
+        light: string;
+    };
+    onThemeSwitch: (themeMode: ThemeMode) => void;
+    size?: ActionIconProps['size'];
+    themeMode: ThemeMode;
+    type?: 'icon' | 'select';
+    variant?: ActionIconProps['variant'];
+}
+
+declare const ThemeSwitch: FC<ThemeSwitchProps>;
+
+type ToastType = 'success' | 'info' | 'warning' | 'error' | 'loading' | 'default';
+type ToastPosition = 'top' | 'top-left' | 'top-right' | 'bottom' | 'bottom-left' | 'bottom-right';
+type ToastActionVariant = 'primary' | 'secondary' | 'text' | 'danger' | 'ghost';
+interface ToastAction {
+    /**
+     * Action button label
+     */
+    label: ReactNode;
+    /**
+     * Click handler
+     */
+    onClick?: () => void;
+    /**
+     * Additional props for the button
+     */
+    props?: Omit<React.ComponentPropsWithRef<'button'>, 'onClick'>;
+    /**
+     * Button variant
+     * @default 'primary'
+     */
+    variant?: ToastActionVariant;
+}
+interface ToastOptions {
+    /**
+     * Action button props
+     * @deprecated Use `actions` instead
+     */
+    actionProps?: React.ComponentPropsWithRef<'button'>;
+    /**
+     * Multiple action buttons
+     */
+    actions?: ToastAction[];
+    /**
+     * Additional class name
+     */
+    className?: string;
+    /**
+     * Whether the toast is closable
+     * @default true
+     */
+    closable?: boolean;
+    /**
+     * Custom data for the toast
+     */
+    data?: Record<string, unknown>;
+    /**
+     * Toast description
+     */
+    description?: ReactNode;
+    /**
+     * Custom duration in milliseconds
+     * @default 5000
+     */
+    duration?: number;
+    /**
+     * Hide the close button
+     * @default false
+     */
+    hideCloseButton?: boolean;
+    /**
+     * Custom icon
+     */
+    icon?: IconProps$1['icon'];
+    /**
+     * Callback when toast is closed
+     */
+    onClose?: () => void;
+    /**
+     * Callback when toast is removed
+     */
+    onRemove?: () => void;
+    /**
+     * Toast placement, overrides global ToastHost position
+     */
+    placement?: ToastPosition;
+    /**
+     * Additional styles
+     */
+    style?: CSSProperties;
+    /**
+     * Toast title
+     */
+    title?: ReactNode;
+    /**
+     * Toast type
+     * @default 'default'
+     */
+    type?: ToastType;
+}
+interface ToastInstance {
+    /**
+     * Close the toast
+     */
+    close: () => void;
+    /**
+     * The toast ID
+     */
+    id: string;
+    /**
+     * Update the toast
+     */
+    update: (options: Partial<ToastOptions>) => void;
+}
+interface ToastProps {
+    classNames?: {
+        action?: string;
+        actions?: string;
+        close?: string;
+        content?: string;
+        description?: string;
+        icon?: string;
+        root?: string;
+        title?: string;
+    };
+    styles?: {
+        action?: CSSProperties;
+        actions?: CSSProperties;
+        close?: CSSProperties;
+        content?: CSSProperties;
+        description?: CSSProperties;
+        icon?: CSSProperties;
+        root?: CSSProperties;
+        title?: CSSProperties;
+    };
+    toast: Toast.Root.ToastObject<ToastOptions>;
+}
+interface ToastPromiseOptions<T> {
+    error: ReactNode | ((error: Error) => ReactNode) | Omit<ToastOptions, 'type'>;
+    loading: ReactNode | Omit<ToastOptions, 'type'>;
+    success: ReactNode | ((data: T) => ReactNode) | Omit<ToastOptions, 'type'>;
+}
+interface ToastAPI {
+    (options: ToastOptions): ToastInstance;
+    dismiss: (id?: string) => void;
+    error: (options: Omit<ToastOptions, 'type'> | string) => ToastInstance;
+    info: (options: Omit<ToastOptions, 'type'> | string) => ToastInstance;
+    loading: (options: Omit<ToastOptions, 'type'> | string) => ToastInstance;
+    promise: <T>(promise: Promise<T>, options: ToastPromiseOptions<T>) => Promise<T>;
+    success: (options: Omit<ToastOptions, 'type'> | string) => ToastInstance;
+    warning: (options: Omit<ToastOptions, 'type'> | string) => ToastInstance;
+}
+
+declare const toast: ToastAPI;
+interface ToastHostProps {
+    className?: string;
+    /**
+     * Default duration for toasts
+     * @default 5000
+     */
+    duration?: number;
+    /**
+     * Maximum number of toasts
+     * @default 5
+     */
+    limit?: number;
+    /**
+     * Toast position
+     * @default 'bottom-right'
+     */
+    position?: ToastPosition;
+    /**
+     * Root element for portal
+     */
+    root?: HTMLElement | ShadowRoot | null;
+    /**
+     * Swipe direction to dismiss
+     * @default ['down', 'right']
+     */
+    swipeDirection?: ('left' | 'right' | 'up' | 'down') | ('left' | 'right' | 'up' | 'down')[];
+}
+declare const ToastHost: react.MemoExoticComponent<({ root, className, duration, limit, position, swipeDirection, }: ToastHostProps) => react.ReactPortal | null>;
+declare const useToast: () => ToastAPI;
+
+interface TocItemType {
+    children?: TocItemType[];
+    id: string;
+    title: string;
+}
+interface TocMobileProps {
+    activeKey?: string;
+    getContainer?: AnchorProps['getContainer'];
+    headerHeight?: number;
+    items: TocItemType[];
+    onChange?: (activeKey: string) => void;
+    tocWidth?: number;
+}
+interface TocProps extends TocMobileProps {
+    isMobile?: boolean;
+}
+
+declare const Toc: react.NamedExoticComponent<TocProps>;
+
+declare const copyToClipboard: (text: string) => Promise<void>;
+
+declare const preventDefault: <T extends {
+    preventDefault: () => void;
+}>(event: T) => void;
+declare const stopPropagation: <T extends {
+    stopPropagation: () => void;
+}>(event: T) => void;
+declare const preventDefaultAndStopPropagation: <T extends {
+    preventBaseUIHandler?: () => void;
+    preventDefault: () => void;
+    stopPropagation: () => void;
+}>(event: T) => void;
+
+declare const _default: {
+    displayName: string;
+    name: string;
+    semanticHighlighting: boolean;
+    tokenColors: ({
+        settings: {
+            foreground: string;
+            fontStyle?: undefined;
+            background?: undefined;
+        };
+        scope?: undefined;
+    } | {
+        scope: string;
+        settings: {
+            foreground: string;
+            fontStyle?: undefined;
+            background?: undefined;
+        };
+    } | {
+        scope: string;
+        settings: {
+            fontStyle: string;
+            foreground: string;
+            background?: undefined;
+        };
+    } | {
+        settings: {
+            background: string;
+            foreground: string;
+            fontStyle?: undefined;
+        };
+        scope?: undefined;
+    } | {
+        scope: string[];
+        settings: {
+            foreground: string;
+            fontStyle?: undefined;
+            background?: undefined;
+        };
+    } | {
+        scope: string[];
+        settings: {
+            fontStyle: string;
+            foreground?: undefined;
+            background?: undefined;
+        };
+    } | {
+        scope: string[];
+        settings: {
+            fontStyle: string;
+            foreground: string;
+            background?: undefined;
+        };
+    })[];
+    type: string;
+};
+
+export { A, type AProps, Accordion, AccordionItem, type AccordionItemProps, type AccordionProps, ActionIcon, ActionIconGroup, type ActionIconGroupEvent, type MenuItemType as ActionIconGroupItemType, type ActionIconGroupProps, type ActionIconProps, type ActionIconSize, Alert, type AlertProps, AutoComplete, type AutoCompleteProps, Avatar, AvatarGroup, type AvatarGroupProps, type AvatarProps, type BaseMenuItemType, Block, type BlockProps, Burger, type BurgerProps, Button, type ButtonProps, type CDN, CLASSNAMES, Center, type CenterProps, Checkbox, CheckboxGroup, type CheckboxGroupOption, type CheckboxGroupProps, type CheckboxProps, CodeDiff, type CodeDiffProps, CodeEditor, type CodeEditorProps, Collapse, type CollapseItemType, type CollapseProps, type ColorPalettes, type ColorPalettesAlpha, ColorSwatches, type ColorSwatchesProps, type ColorToken, type Config, ConfigProvider, type ContextMenuCheckboxItem, ContextMenuHost, type ContextMenuItem, ContextMenuTrigger, CopyButton, type CopyButtonProps, DROPDOWN_MENU_CONTAINER_ATTR, DatePicker, type DatePickerProps, type DiffViewMode, type DivProps$1 as DivProps, DownloadButton, type DownloadButtonProps, DraggablePanel, DraggablePanelBody, type DraggablePanelBodyProps, DraggablePanelContainer, type DraggablePanelContainerProps, DraggablePanelFooter, type DraggablePanelFooterProps, DraggablePanelHeader, type DraggablePanelHeaderProps, type DraggablePanelProps, DraggableSideNav, type DraggableSideNavProps, Drawer, type DrawerProps, Dropdown, type DropdownItem, DropdownMenu, type DropdownMenuCheckboxItem, DropdownMenuCheckboxItemIndicator, DropdownMenuCheckboxItemPrimitive, DropdownMenuGroup, DropdownMenuGroupLabel, type DropdownMenuGroupLabelProps, DropdownMenuItem, DropdownMenuItemContent, type DropdownMenuItemContentProps, DropdownMenuItemExtra, type DropdownMenuItemExtraProps, DropdownMenuItemIcon, type DropdownMenuItemIconProps, DropdownMenuItemLabel, type DropdownMenuItemLabelProps, type DropdownMenuItemProps, type MenuItemType as DropdownMenuItemType, type DropdownMenuPlacement, DropdownMenuPopup, type DropdownMenuPopupProps, DropdownMenuPortal, type DropdownMenuPortalProps, DropdownMenuPositioner, type DropdownMenuPositionerProps, type DropdownMenuProps, DropdownMenuRoot, DropdownMenuSeparator, type DropdownMenuSeparatorProps, DropdownMenuSubmenuArrow, type DropdownMenuSubmenuArrowProps, DropdownMenuSubmenuRoot, DropdownMenuSubmenuTrigger, type DropdownMenuSubmenuTriggerProps, DropdownMenuTrigger, type DropdownMenuTriggerProps, type DropdownProps, EditableText, type EditableTextProps, EditorSlashMenu, EditorSlashMenuGroup$1 as EditorSlashMenuGroup, type EditorSlashMenuItems, type EditorSlashMenuOption, EmojiPicker, type EmojiPickerProps, Empty, type EmptyProps, FileTypeIcon, type FileTypeIconProps, _default$9 as FlexBasic, type FlexBasicProps, _default$9 as Flexbox, type FlexboxProps, FluentEmoji, type FluentEmojiProps, FontLoader, type FontLoaderProps, Footer, type FooterProps, Form, FormGroup, type FormGroupItemType, type FormGroupProps, FormItem, type FormItemProps, FormModal, type FormModalProps, type FormProps, FormSubmitFooter, type FormSubmitFooterProps, FormTitle, type FormTitleProps, type GenericItemType, Grid, type GridProps, GroupAvatar, type GroupAvatarProps, GuideCard, type GuideCardProps, Header, type HeaderProps, Highlighter, type HighlighterProps, Hotkey, HotkeyInput, type HotkeyInputProps, type HotkeyProps, I18nProvider, type I18nProviderProps, Icon, type IconProps$1 as IconProps, IconProvider, type IconSize, Image, type ImageProps$1 as ImageProps, ImageSelect, type ImageSelectItem, type ImageSelectProps, type ImgProps, type ImperativeModalProps, Input, InputNumber, type InputNumberProps, InputOPT, type InputOPTProps, InputPassword, type InputPasswordProps, type InputProps, type ItemType, KeyMapEnum, LOBE_SELECT_CONTAINER_ATTR, LOBE_THEME_APP_ID, Layout, LayoutFooter, type LayoutFooterProps, LayoutHeader, type LayoutHeaderProps, LayoutMain, type LayoutMainProps, type LayoutProps, LayoutSidebar, LayoutSidebarInner, type LayoutSidebarInnerProps, type LayoutSidebarProps, LayoutToc, type LayoutTocProps, List, ListItem, type ListItemProps, type ListProps, type LobeCustomStylish, type LobeCustomToken, LobeSelect, LobeSelectArrow, type LobeSelectArrowProps, LobeSelectBackdrop, LobeSelectGroup, LobeSelectGroupLabel, type LobeSelectGroupLabelProps, type LobeSelectGroupProps, LobeSelectIcon, type LobeSelectIconProps, LobeSelectItem, LobeSelectItemIndicator, type LobeSelectItemIndicatorProps, type LobeSelectItemProps, LobeSelectItemText, type LobeSelectItemTextProps, LobeSelectList, type LobeSelectListProps, LobeSelectPopup, type LobeSelectPopupProps, LobeSelectPortal, type LobeSelectPortalProps, LobeSelectPositioner, type LobeSelectPositionerProps, type LobeSelectProps, LobeSelectRoot, LobeSelectScrollDownArrow, type LobeSelectScrollDownArrowProps, LobeSelectScrollUpArrow, type LobeSelectScrollUpArrowProps, LobeSelectSeparator, LobeSelectTrigger, type LobeSelectTriggerProps, LobeSelectValue, type LobeSelectValueProps, LobeSwitch, type LobeSwitchChangeEventHandler, type LobeSwitchClassNames, type LobeSwitchClickEventHandler, type LobeSwitchContextType, LobeSwitchIcon, type LobeSwitchIconPosition, type LobeSwitchIconProps, type LobeSwitchProps, LobeSwitchRoot, type LobeSwitchRootProps, type LobeSwitchSize, type LobeSwitchStyles, LobeSwitchThumb, type LobeSwitchThumbProps, I18nProvider as LobeUIProvider, Markdown, type MarkdownProps, MaskShadow, type MaskShadowProps, MaterialFileTypeIcon, type MaterialFileTypeIconProps, Menu, type MenuCheckboxItemType, type MenuItemType, type MenuProps, Mermaid, type MermaidProps, Meta, type MetaProps, Modal, ModalHost, type ModalHostProps, type ModalInstance, type ModalProps, ModalProvider, MotionComponent, type MotionComponentType, MotionProvider, type NeutralColors, type NeutralColorsObj, POPOVER_CONTAINER_ATTR, PatchDiff, type PatchDiffProps, type Placement, type PlacementConfig, Popover, PopoverArrow, type PopoverArrowAtomProps, PopoverArrowIcon, PopoverBackdrop, type PopoverContextValue, PopoverGroup, type PopoverPlacement, PopoverPopup, type PopoverPopupAtomProps, PopoverPortal, type PopoverPortalAtomProps, PopoverPositioner, type PopoverPositionerAtomProps, type PopoverProps, PopoverProvider, PopoverRoot, type PopoverTrigger, PopoverTriggerElement, type PopoverTriggerElementProps, PopoverViewport, type PopoverViewportAtomProps, type PresetColorKey, type PresetColorType, type PresetSystemColorKey, type PresetSystemColorType, PreviewGroup, type PreviewGroupProps, type PrimaryColors, type PrimaryColorsObj, type RawModalComponent, type RawModalComponentProps, type RawModalInstance, type RawModalKeyOptions, type RawModalOptions, ScrollArea, ScrollAreaContent, type ScrollAreaContentProps, ScrollAreaCorner, type ScrollAreaCornerProps, type ScrollAreaProps, ScrollAreaRoot, type ScrollAreaRootProps, ScrollAreaScrollbar, type ScrollAreaScrollbarProps, ScrollAreaThumb, type ScrollAreaThumbProps, ScrollAreaViewport, type ScrollAreaViewportProps, ScrollShadow, type ScrollShadowProps, SearchBar, type SearchBarProps, SearchResultCards, type SearchResultCardsProps, Segmented, type SegmentedProps, Select, type SelectProps, _default as ShikiLobeTheme, SideNav, type SideNavProps, Skeleton, SkeletonAvatar, type SkeletonAvatarProps, SkeletonBlock, type SkeletonBlockProps, SkeletonButton, type SkeletonButtonProps, SkeletonParagraph, type SkeletonParagraphProps, type SkeletonProps, SkeletonTags, type SkeletonTagsProps, SkeletonTitle, type SkeletonTitleProps, SliderWithInput, type SliderWithInputProps, Snippet, type SnippetProps, SortableList, type SortableListProps, type SpanProps, type SvgProps, SyntaxHighlighter, type SyntaxHighlighterProps, SyntaxMermaid, type SyntaxMermaidProps, type SystemColorToken, Tabs, type TabsProps, Tag, type TagProps, Text, TextArea, type TextAreaProps, type TextProps, ThemeProvider, type ThemeProviderProps, ThemeSwitch, type ThemeSwitchProps, type ToastAPI, ToastHost, type ToastHostProps, type ToastInstance, type ToastOptions, type ToastPosition, type ToastPromiseOptions, type ToastProps, type ToastType, Toc, type TocProps, Tooltip, TooltipGroup, type TooltipProps, type Trigger, Typography, type TypographyProps, Video, type VideoProps$1 as VideoProps, closeContextMenu, combineKeys, copyToClipboard, createModal, createRawModal, findCustomThemeName, genCdnUrl, generateColorNeutralPalette, generateColorPalette, highlighterThemes, generateCustomStylish as lobeCustomStylish, generateCustomToken as lobeCustomToken, staticStylish as lobeStaticStylish, styles$1 as lobeSwitchStyles, styles as menuSharedStyles, mermaidThemes, neutralColors, neutralColorsSwatches, placementMap, preprocessMarkdownContent, preventDefault, preventDefaultAndStopPropagation, primaryColors, primaryColorsSwatches, rehypeCustomFootnotes, rehypeKatexDir, rehypeStreamAnimated, remarkBr, remarkColor, remarkCustomFootnotes, remarkGfmPlus, remarkVideo, renderDropdownMenuItems, showContextMenu, stopPropagation, toFloatingUIPlacement, toast, updateContextMenuItems, useCdnFn, useLobeSwitchContext, useModalContext, useMotionComponent, usePopoverContext, usePopoverPortalContainer, useToast, useTranslation };