@gomeniucivan/ui 1.0.43 → 1.0.45

package/dist/index.d.mts

@@ -0,0 +1,4236 @@
+import * as react from 'react';
+import react__default, { AnchorHTMLAttributes, HTMLAttributes, FC, Ref, ElementType, CSSProperties, ReactNode, Key, ReactElement, ComponentPropsWithRef, RefAttributes, Context, MouseEvent, ComponentProps, ChangeEvent, FocusEvent, FormEvent, FormHTMLAttributes, KeyboardEvent, ComponentType } from 'react';
+import { FlexProps as FlexProps$1, 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, SegmentedProps as SegmentedProps$1, ModalProps as ModalProps$1, ImageProps as ImageProps$2, SelectProps as SelectProps$1, TagProps as TagProps$1, TabsProps as TabsProps$1, AnchorProps, SliderSingleProps } from 'antd';
+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 { 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 { ConfigType } from 'dayjs';
+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 Inputmask from 'inputmask';
+import { InputNumberRef } from 'rc-input-number';
+import { Size, NumberSize } from 're-resizable';
+import { Props as Props$1 } from 'react-rnd';
+import { DropdownProps as DropdownProps$1 } from 'antd/es';
+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 { Switch as Switch$1 } from '@base-ui/react/switch';
+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 { 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 { TableProps as TableProps$1 } from 'antd/es/table';
+import { GetCustomStylish, GetCustomToken, ThemeProviderProps as ThemeProviderProps$1, CustomStylishParams, CustomTokenParams, ThemeMode } from 'antd-style';
+export { createStyles, cx, useAntdToken as useToken } 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 = 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 FlexDirection = 'vertical' | 'vertical-reverse' | 'horizontal' | 'horizontal-reverse';
+interface FlexProps extends FlexProps$1 {
+    as?: ElementType;
+    direction?: FlexDirection;
+    distribution?: CSSProperties['justifyContent'];
+    horizontal?: boolean;
+    vertical?: boolean;
+    padding?: number | string;
+    paddingBlock?: number | string;
+    paddingInline?: number | string;
+    width?: number | string;
+    height?: number | string;
+    allowShrink?: boolean;
+    visible?: boolean;
+    ref?: Ref<HTMLElement>;
+}
+declare const Flex: react.ForwardRefExoticComponent<Omit<FlexProps, "ref"> & react.RefAttributes<HTMLElement>>;
+
+interface BlockProps extends FlexProps {
+    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<FlexProps, '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<FlexProps, '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<FlexProps, '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<FlexProps, '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 {
+    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, '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<FlexProps, '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<FlexProps, '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<FlexProps, '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<FlexProps, '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<FlexProps, '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;
+    /**
+     * Force mobile drawer / wheel UI when true; otherwise uses ThemeProvider context.
+     */
+    isMobile?: boolean;
+    /**
+     * Lower bound for selectable dates (inclusive).
+     */
+    min?: ConfigType;
+    /**
+     * Upper bound for selectable dates (inclusive).
+     */
+    max?: ConfigType;
+    /**
+     * Show years in ascending order instead of the default descending order.
+     */
+    revertYear?: boolean;
+}
+
+declare const DatePicker: react.NamedExoticComponent<DatePickerProps>;
+
+interface DownloadButtonProps extends ActionIconProps {
+    blobUrl?: string;
+    fileName?: string;
+    fileType?: string;
+}
+
+declare const DownloadButton: react__default.NamedExoticComponent<DownloadButtonProps>;
+
+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;
+}
+interface InputMaskProps extends InputProps$1 {
+    ref?: Ref<InputRef>;
+    shadow?: boolean;
+    mask: NonNullable<Inputmask.Options['mask']>;
+    maskChar?: string | null;
+    maskPlaceholder?: string | null;
+    alwaysShowMask?: boolean;
+}
+
+type SelectSize = 'large' | 'middle' | 'small';
+type SelectVariant = 'borderless' | 'filled' | 'outlined';
+type SelectBehaviorVariant = '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 SelectIndicatorVariant = 'check' | 'bold';
+interface SelectOption<Value = string> {
+    className?: string;
+    disabled?: boolean;
+    label: ReactNode;
+    style?: CSSProperties;
+    title?: string;
+    value: Value;
+}
+interface SelectOptionGroup<Value = string> {
+    disabled?: boolean;
+    label: ReactNode;
+    options: SelectOption<Value>[];
+}
+type SelectOptions<Value = string> = Array<SelectOption<Value> | SelectOptionGroup<Value>>;
+interface SelectClassNames {
+    clear?: string;
+    dropdown?: string;
+    empty?: string;
+    group?: string;
+    groupLabel?: string;
+    icon?: string;
+    item?: string;
+    itemIndicator?: string;
+    itemText?: string;
+    list?: string;
+    mobileClose?: string;
+    mobileContent?: string;
+    mobileGroupLabel?: string;
+    mobileHeader?: string;
+    mobileList?: string;
+    mobileOverlay?: string;
+    mobileOption?: string;
+    mobileOptionCheck?: string;
+    mobileOptionLabel?: string;
+    mobileOptionSelected?: string;
+    mobileSheet?: string;
+    mobileTitle?: string;
+    option?: string;
+    popup?: string;
+    prefix?: string;
+    root?: string;
+    search?: string;
+    suffix?: string;
+    trigger?: string;
+    value?: string;
+}
+interface SelectProps<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?: SelectBehaviorVariant;
+    className?: string;
+    classNames?: SelectClassNames;
+    defaultOpen?: boolean;
+    defaultValue?: Value | Value[] | null;
+    disabled?: boolean;
+    id?: string;
+    /**
+     * When true, uses a mobile drawer picker (recommended for touch devices).
+     * @default false
+     */
+    isMobile?: boolean;
+    labelRender?: (option: SelectOption<Value>) => ReactNode;
+    /**
+     * 设置弹窗滚动高度
+     * @default 256
+     */
+    listHeight?: number;
+    listItemHeight?: number;
+    loading?: boolean;
+    mode?: 'multiple' | 'tags';
+    name?: string;
+    onChange?: (value: Value | Value[] | null, option?: SelectOption<Value> | SelectOption<Value>[]) => void;
+    onOpenChange?: (open: boolean) => void;
+    onSelect?: (value: Value, option?: SelectOption<Value>) => void;
+    open?: boolean;
+    optionRender?: (option: SelectOption<Value>, info: {
+        index: number;
+    }) => ReactNode;
+    options?: SelectOptions<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?: SelectIndicatorVariant;
+    shadow?: boolean;
+    showSearch?: boolean;
+    size?: SelectSize;
+    style?: CSSProperties;
+    styles?: {
+        popup?: {
+            root?: CSSProperties;
+        };
+    };
+    suffixIcon?: IconProps$1['icon'] | ReactNode;
+    suffixIconProps?: Omit<IconProps$1, 'icon'>;
+    tokenSeparators?: string[];
+    value?: Value | Value[] | null;
+    variant?: SelectVariant;
+    virtual?: boolean;
+}
+
+type Meridiem = 'AM' | 'PM';
+type TimeValue = {
+    hour: number;
+    minute: number;
+};
+interface TimePickerProps extends Omit<InputProps, 'defaultValue' | 'onChange' | 'type' | 'value' | 'size' | 'status' | 'addonAfter' | 'addonBefore' | 'suffix'> {
+    allowClear?: boolean;
+    className?: string;
+    defaultOpen?: boolean;
+    defaultValue?: string | null;
+    format?: string | ((value: TimeValue | null) => string);
+    hourStep?: number;
+    /**
+     * Force mobile drawer / wheel UI when true; otherwise uses ThemeProvider context.
+     */
+    isMobile?: boolean;
+    inputReadOnly?: boolean;
+    minuteStep?: number;
+    onChange?: (value: string | null, formatted: string) => void;
+    onOpenChange?: (open: boolean) => void;
+    open?: boolean;
+    placeholder?: string;
+    size?: SelectSize;
+    style?: CSSProperties;
+    use12Hours?: boolean;
+    value?: string | null;
+}
+
+declare const TimePicker: react.NamedExoticComponent<TimePickerProps>;
+
+type DraggablePanelBodyProps = DivProps;
+declare const DraggablePanelBody: react.NamedExoticComponent<DivProps>;
+
+type DraggablePanelContainerProps = DivProps;
+declare const DraggablePanelContainer: react.NamedExoticComponent<DivProps>;
+
+type DraggablePanelFooterProps = DivProps;
+declare const DraggablePanelFooter: react.NamedExoticComponent<DivProps>;
+
+interface DraggablePanelHeaderProps extends Omit<DivProps, '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 {
+    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, '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>;
+
+declare const Input: react.NamedExoticComponent<InputProps>;
+
+declare const InputMask: react.NamedExoticComponent<InputMaskProps>;
+
+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<FlexProps, '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<FlexProps, '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<FlexProps, 'title'> {
+    action?: ReactNode;
+    actionProps?: Omit<FlexProps, '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;
+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 {
+    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 FlexProps {
+    bottom?: ReactNode;
+    columns: FooterProps$1['columns'];
+    contentMaxWidth?: number;
+    theme?: 'light' | 'dark';
+}
+
+declare const Footer: react.NamedExoticComponent<FooterProps>;
+
+interface FormConfig<T extends Record<string, any>> {
+    initialValues: T;
+    onSubmit: (values: T) => void | Promise<void>;
+    validate?: (values: T) => Partial<Record<keyof T, string>>;
+}
+interface FormState<T extends Record<string, any>> {
+    values: T;
+    errors: Partial<Record<keyof T, string>>;
+    fieldErrors: Partial<Record<keyof T, string>>;
+    touched: Partial<Record<keyof T, boolean>>;
+    isSubmitting: boolean;
+    isValid: boolean;
+    validationSequence: number;
+}
+declare function useForm<T extends Record<string, any>>(config: FormConfig<T>): {
+    readonly form: {
+        readonly values: T;
+        readonly errors: Partial<Record<keyof T, string>>;
+        readonly fieldErrors: Partial<Record<keyof T, string>>;
+        readonly touched: Partial<Record<keyof T, boolean>>;
+        readonly validationSequence: number;
+        readonly setFieldValue: (field: PropertyKey, value: unknown) => void;
+        readonly setFieldError: (field: PropertyKey, error?: string) => void;
+        readonly setFieldTouched: (field: PropertyKey, touched?: boolean) => void;
+        readonly handleChange: (e: ChangeEvent<HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement>) => void;
+        readonly handleBlur: (e: FocusEvent<HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement>) => void;
+        readonly handleSubmit: (e?: FormEvent) => Promise<void>;
+        readonly resetForm: () => void;
+        readonly validateForm: () => boolean;
+        readonly triggerValidation: () => void;
+        readonly isSubmitting: boolean;
+        readonly isValid: boolean;
+    };
+    readonly setFieldValue: (field: keyof T, value: any) => void;
+    readonly setFieldTouched: (field: keyof T, touched?: boolean) => void;
+    readonly setFieldError: (field: keyof T, error?: string) => void;
+    readonly handleChange: (e: ChangeEvent<HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement>) => void;
+    readonly handleBlur: (e: FocusEvent<HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement>) => void;
+    readonly handleSubmit: (e?: FormEvent) => void;
+    readonly resetForm: () => void;
+    readonly validateForm: () => boolean;
+    readonly triggerValidation: () => void;
+    readonly values: T;
+    readonly errors: Partial<Record<keyof T, string>>;
+    readonly fieldErrors: Partial<Record<keyof T, string>>;
+    readonly touched: Partial<Record<keyof T, boolean>>;
+    readonly isSubmitting: boolean;
+    readonly isValid: boolean;
+    readonly validationSequence: number;
+};
+type UseFormReturn<T extends Record<string, any>> = ReturnType<typeof useForm<T>>;
+type FormInstance<T extends Record<string, any>> = UseFormReturn<T>['form'];
+
+type FormVariant = 'borderless' | 'filled' | 'outlined';
+interface FormProps<T extends Record<string, any>> extends Omit<FormHTMLAttributes<HTMLFormElement>, 'onSubmit'> {
+    children: ReactNode;
+    onSubmit?: (values: T) => void | Promise<void>;
+    form?: FormInstance<T>;
+    initialValues?: T;
+    validate?: (values: T) => Partial<Record<keyof T, string>>;
+    className?: string;
+    /**
+     * Layout of form fields.
+     * - `vertical`: label/description stacked above control (default)
+     * - `horizontal`: label/description on the left, control on the right
+     */
+    layout?: 'vertical' | 'horizontal';
+    /**
+     * When `layout="horizontal"`, sets the width of the label/description column.
+     * Accepts any CSS width value (e.g., `180px`, `12rem`, `30%`).
+     * @default '200px'
+     */
+    labelWidth?: string | number;
+    fieldMinWidth?: string | number;
+    /**
+     * Shared visual style for form wrappers and field components.
+     * @default 'borderless'
+     */
+    variant?: FormVariant;
+}
+interface FormGroupProps {
+    /** Group title */
+    title?: ReactNode;
+    /** Group description */
+    description?: ReactNode;
+    /** Group icon (component or element) */
+    icon?: any;
+    /** Extra content on the right side of the header */
+    extra?: ReactNode;
+    /** Group children */
+    children?: ReactNode;
+    /** Additional CSS class */
+    className?: string;
+    /** Style object */
+    style?: CSSProperties;
+    /** Whether the group is collapsible */
+    collapsible?: boolean;
+    /** Whether the group is collapsed by default */
+    defaultCollapsed?: boolean;
+    /** Variant style for the group container */
+    variant?: FormVariant;
+}
+
+declare function Form<T extends Record<string, any>>({ children, onSubmit, form, initialValues, validate, className, style, layout, labelWidth, variant, fieldMinWidth, ...props }: FormProps<T>): react_jsx_runtime.JSX.Element;
+declare namespace Form {
+    var displayName: string;
+}
+
+type FormErrorProps = {
+    message?: string;
+    className?: string;
+    style?: react__default.CSSProperties;
+};
+declare const FormError: {
+    ({ message, className, style }: FormErrorProps): react_jsx_runtime.JSX.Element | null;
+    displayName: string;
+};
+
+type FormInputProps<T extends Record<string, any>> = Omit<InputProps, 'name' | 'value' | 'onChange' | 'onBlur' | 'defaultValue' | 'form'> & {
+    name: keyof T & string;
+    label?: string;
+    description?: react__default.ReactNode;
+    form?: FormInstance<T>;
+    required?: boolean;
+    helperText?: react__default.ReactNode;
+    onChange?: InputProps['onChange'];
+    onBlur?: InputProps['onBlur'];
+    rules?: FormFieldRules<T>;
+};
+type FormFieldRules<T extends Record<string, any>> = {
+    required?: boolean | string | {
+        message: string;
+    };
+    pattern?: {
+        value: RegExp;
+        message: string;
+    };
+    minLength?: {
+        value: number;
+        message: string;
+    };
+    maxLength?: {
+        value: number;
+        message: string;
+    };
+    validate?: (value: any, values: T) => string | boolean | void;
+} | string;
+declare const runRules: <T extends Record<string, any>>(rules: FormFieldRules<T> | undefined, value: any, values: T) => string | undefined;
+declare const FormInput: {
+    <T extends Record<string, any>>({ name, label, description, form, required, helperText, className, id, variant: inputVariant, onChange, onBlur, rules, ...inputProps }: FormInputProps<T>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+type FormLabelProps = {
+    htmlFor?: string;
+    children: react__default.ReactNode;
+    className?: string;
+    description?: react__default.ReactNode;
+    required?: boolean;
+};
+declare const FormLabel: {
+    ({ htmlFor, children, className, description, required }: FormLabelProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+type FormTimePickerProps<T extends Record<string, any>> = Omit<TimePickerProps, 'name' | 'value' | 'onChange' | 'defaultValue' | 'form'> & {
+    name: keyof T & string;
+    label?: string;
+    description?: react__default.ReactNode;
+    form?: FormInstance<T>;
+    required?: boolean;
+    onValueChange?: (value: string | null, formatted: string) => void;
+    rules?: FormFieldRules<T>;
+};
+declare const FormTimePicker: {
+    <T extends Record<string, any>>({ name, label, description, form, required, className, variant: timeVariant, onValueChange, rules, ...pickerProps }: FormTimePickerProps<T>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+type FormCheckboxProps<T extends Record<string, any>> = Omit<CheckboxProps, 'checked' | 'defaultChecked' | 'onChange'> & {
+    name: keyof T & string;
+    label?: react__default.ReactNode;
+    description?: react__default.ReactNode;
+    form?: FormInstance<T>;
+    rules?: FormFieldRules<T>;
+    onChange?: (checked: boolean) => void;
+};
+declare const FormCheckbox: {
+    <T extends Record<string, any>>({ name, label, description, form, className, rules, onChange, ...rest }: FormCheckboxProps<T>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+type SwitchSize = 'default' | 'small';
+type SwitchChangeEventHandler = (checked: boolean, event: MouseEvent<HTMLButtonElement> | KeyboardEvent<HTMLButtonElement>) => void;
+type SwitchClickEventHandler = SwitchChangeEventHandler;
+interface SwitchClassNames {
+    content?: string;
+    root?: string;
+    thumb?: string;
+}
+interface SwitchStyles {
+    content?: CSSProperties;
+    root?: CSSProperties;
+    thumb?: CSSProperties;
+}
+interface SwitchContextType {
+    isChecked: boolean;
+    isPressed: boolean;
+    setIsChecked: (checked: boolean) => void;
+    setIsPressed: (pressed: boolean) => void;
+}
+type SwitchRootProps = Omit<ComponentProps<typeof Switch$1.Root>, 'render'> & HTMLMotionProps<'button'> & {
+    size?: SwitchSize;
+};
+type SwitchThumbProps = Omit<ComponentProps<typeof Switch$1.Thumb>, 'render'> & HTMLMotionProps<'span'> & {
+    pressedAnimation?: TargetAndTransition | boolean;
+    size?: SwitchSize;
+    transition?: Transition;
+};
+type SwitchIconPosition = 'left' | 'right' | 'thumb';
+type SwitchIconProps = HTMLMotionProps<'span'> & {
+    position: SwitchIconPosition;
+    transition?: Transition;
+};
+interface SwitchProps {
+    /**
+     * 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?: SwitchClassNames;
+    /**
+     * 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?: SwitchChangeEventHandler;
+    /**
+     * Callback when clicking the switch
+     */
+    onClick?: SwitchClickEventHandler;
+    /**
+     * Reference to the root element
+     */
+    ref?: Ref<HTMLButtonElement>;
+    /**
+     * Additional class name for root element
+     */
+    rootClassName?: string;
+    /**
+     * Size of the switch
+     * @default 'default'
+     */
+    size?: SwitchSize;
+    /**
+     * Custom inline style
+     */
+    style?: CSSProperties;
+    /**
+     * Custom styles for each part
+     */
+    styles?: SwitchStyles;
+    /**
+     * 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;
+}
+
+type FormSwitchProps<T extends Record<string, any>> = Omit<SwitchProps, 'checked' | 'defaultChecked' | 'onChange' | 'value'> & {
+    name: keyof T & string;
+    label?: string;
+    description?: react__default.ReactNode;
+    form?: FormInstance<T>;
+    rules?: FormFieldRules<T>;
+    onChange?: (checked: boolean) => void;
+};
+declare const FormSwitch: {
+    <T extends Record<string, any>>({ name, label, description, form, className, rules, onChange, ...rest }: FormSwitchProps<T>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+type FormDatePickerProps<T extends Record<string, any>> = Omit<DatePickerProps, 'name' | 'value' | 'onChange' | 'defaultValue' | 'form'> & {
+    name: keyof T & string;
+    label?: string;
+    description?: react__default.ReactNode;
+    form?: FormInstance<T>;
+    rules?: FormFieldRules<T>;
+};
+declare const FormDatePicker: {
+    <T extends Record<string, any>>({ name, label, description, form, className, variant: dateVariant, rules, ...rest }: FormDatePickerProps<T>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+type FormSelectProps<T extends Record<string, any>, Value = string> = Omit<SelectProps<Value>, 'name' | 'value' | 'onChange' | 'defaultValue' | 'form'> & {
+    name: keyof T & string;
+    label?: string;
+    description?: react__default.ReactNode;
+    form?: FormInstance<T>;
+    rules?: FormFieldRules<T>;
+    options?: SelectOption<Value>[];
+};
+declare const FormSelect: {
+    <T extends Record<string, any>, Value = string>({ name, label, description, form, className, variant: selectVariant, rules, ...rest }: FormSelectProps<T, Value>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+interface SegmentedProps extends SegmentedProps$1 {
+    glass?: boolean;
+    iconProps?: Omit<IconProps$1, 'icon'>;
+    padding?: string | number;
+    ref?: Ref<HTMLDivElement>;
+    shadow?: boolean;
+    variant?: 'filled' | 'outlined' | 'borderless';
+}
+
+type FormSegmentProps<T extends Record<string, any>> = Omit<SegmentedProps, 'name' | 'value' | 'onChange' | 'defaultValue' | 'form'> & {
+    name: keyof T & string;
+    label?: string;
+    description?: react__default.ReactNode;
+    form?: FormInstance<T>;
+    rules?: FormFieldRules<T>;
+};
+declare const FormSegment: {
+    <T extends Record<string, any>>({ name, label, description, form, className, rules, ...rest }: FormSegmentProps<T>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+declare const FormGroup: {
+    ({ title, description, icon, extra, children, className, style, collapsible, defaultCollapsed, variant: groupVariant, }: FormGroupProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+type FormComponent = <T extends Record<string, any>>(props: FormProps<T> & RefAttributes<HTMLFormElement>) => ReturnType<typeof Form>;
+type FormCompound = FormComponent & {
+    Input: typeof FormInput;
+    Label: typeof FormLabel;
+    Error: typeof FormError;
+    TimePicker: typeof FormTimePicker;
+    Checkbox: typeof FormCheckbox;
+    Switch: typeof FormSwitch;
+    DatePicker: typeof FormDatePicker;
+    Select: typeof FormSelect;
+    Segment: typeof FormSegment;
+    Group: typeof FormGroup;
+};
+declare const FormComponentImpl: FormCompound;
+
+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;
+
+interface FormModalProps<T extends Record<string, any>> extends Omit<ModalProps, 'footer' | 'onOk' | 'children' | 'title'> {
+    children: ReactNode;
+    form?: FormInstance<T>;
+    initialValues?: T;
+    onSubmit?: FormProps<T>['onSubmit'];
+    submitButtonProps?: ButtonProps;
+    submitText?: string;
+    title?: ReactNode;
+    validate?: FormProps<T>['validate'];
+    loading?: boolean;
+}
+
+declare const FormModal: {
+    <T extends Record<string, any>>({ children, form, initialValues, onSubmit, validate, submitText, submitButtonProps, loading, ...modalProps }: FormModalProps<T>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+interface GridProps extends Omit<FlexProps, '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<FlexProps, '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 FlexProps {
+    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 {
+    animated?: boolean;
+    children: string;
+    enableTransformer?: HighlighterProps['enableTransformer'];
+    language: HighlighterProps['language'];
+    ref?: Ref<HTMLDivElement>;
+    theme?: HighlighterProps['theme'];
+    variant?: HighlighterProps['variant'];
+}
+interface HighlighterProps extends Omit<FlexProps, '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 {
+    classNames?: {
+        root?: string;
+    };
+    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 FlexProps {
+    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>;
+
+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;
+interface LayoutHeaderProps extends DivProps {
+    headerHeight?: number;
+}
+type LayoutMainProps = DivProps;
+interface LayoutSidebarProps extends DivProps {
+    headerHeight?: number;
+}
+interface LayoutSidebarInnerProps extends DivProps {
+    headerHeight?: number;
+}
+interface LayoutTocProps extends DivProps {
+    tocWidth?: number;
+}
+
+declare const LayoutHeader: react.NamedExoticComponent<LayoutHeaderProps>;
+
+declare const LayoutMain: react.NamedExoticComponent<DivProps>;
+
+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<FlexProps, '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<FlexProps, '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;
+
+declare const SELECT_CONTAINER_ATTR = "data-custom-select-container";
+declare const CUSTOM_SELECT_CONTAINER_ATTR = "data-custom-select-container";
+
+declare const SelectRoot: typeof Select$1.Root;
+declare const SelectBackdrop: react.ForwardRefExoticComponent<_base_ui_react_select.SelectBackdropProps & react.RefAttributes<HTMLDivElement>>;
+declare const SelectSeparator: react.ForwardRefExoticComponent<node_modules__base_ui_react_esm_separator_Separator.SeparatorProps & react.RefAttributes<HTMLDivElement>>;
+type SelectTriggerProps = Omit<ComponentPropsWithRef<typeof Select$1.Trigger>, 'children' | 'render'> & {
+    children: ComponentProps<typeof Select$1.Trigger>['children'];
+    shadow?: boolean;
+    size?: SelectSize;
+    variant?: SelectVariant;
+};
+declare const SelectTrigger: {
+    ({ children, className, nativeButton, shadow, size, variant, ref: refProp, ...rest }: SelectTriggerProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type SelectIconProps = ComponentProps<typeof Select$1.Icon>;
+declare const SelectIcon: {
+    ({ className, ...rest }: SelectIconProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type SelectValueProps = ComponentProps<typeof Select$1.Value>;
+declare const SelectValue: {
+    ({ className, ...rest }: SelectValueProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type SelectPortalProps = ComponentProps<typeof Select$1.Portal> & {
+    /**
+     * When `container` is not provided, it uses a shared container created by `usePortalContainer`.
+     */
+    container?: HTMLElement | null;
+};
+declare const SelectPortal: {
+    ({ container, ...rest }: SelectPortalProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type SelectPositionerProps = ComponentProps<typeof Select$1.Positioner>;
+declare const SelectPositioner: {
+    ({ align, alignItemWithTrigger, className, side, sideOffset, ...rest }: SelectPositionerProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type SelectPopupProps = ComponentProps<typeof Select$1.Popup>;
+declare const SelectPopup: {
+    ({ className, ...rest }: SelectPopupProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type SelectListProps = ComponentProps<typeof Select$1.List>;
+declare const SelectList: {
+    ({ className, ...rest }: SelectListProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type SelectItemProps = ComponentProps<typeof Select$1.Item>;
+declare const SelectItem: {
+    ({ className, ...rest }: SelectItemProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type SelectItemTextProps = ComponentProps<typeof Select$1.ItemText>;
+declare const SelectItemText: {
+    ({ className, ...rest }: SelectItemTextProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type SelectItemIndicatorProps = ComponentProps<typeof Select$1.ItemIndicator>;
+declare const SelectItemIndicator: {
+    ({ className, ...rest }: SelectItemIndicatorProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type SelectGroupProps = ComponentProps<typeof Select$1.Group>;
+declare const SelectGroup: {
+    ({ className, ...rest }: SelectGroupProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type SelectGroupLabelProps = ComponentProps<typeof Select$1.GroupLabel>;
+declare const SelectGroupLabel: {
+    ({ className, ...rest }: SelectGroupLabelProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type SelectScrollUpArrowProps = ComponentProps<typeof Select$1.ScrollUpArrow>;
+declare const SelectScrollUpArrow: {
+    ({ className, ...rest }: SelectScrollUpArrowProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type SelectScrollDownArrowProps = ComponentProps<typeof Select$1.ScrollDownArrow>;
+declare const SelectScrollDownArrow: {
+    ({ className, ...rest }: SelectScrollDownArrowProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+type SelectArrowProps = ComponentProps<typeof Select$1.Arrow>;
+declare const SelectArrow: {
+    ({ className, ...rest }: SelectArrowProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+declare const Select: react.NamedExoticComponent<SelectProps<any>>;
+
+declare const useSwitchContext: () => SwitchContextType;
+type SwitchRootInternalProps = Omit<SwitchRootProps, 'onCheckedChange' | 'onClick'> & {
+    onCheckedChange?: SwitchChangeEventHandler;
+    onClick?: SwitchChangeEventHandler;
+};
+declare const SwitchRoot: {
+    ({ checked, className, defaultChecked, onCheckedChange, onClick, size, children, disabled, readOnly, required, inputRef, id, name, ...rest }: SwitchRootInternalProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const SwitchThumb: {
+    ({ className, pressedAnimation, size, transition, children, ...rest }: SwitchThumbProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const SwitchIcon: {
+    ({ children, className, position, transition, ...rest }: SwitchIconProps & {
+        children?: React.ReactNode;
+        size?: "default" | "small";
+    }): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+declare const Switch: react.NamedExoticComponent<SwitchProps>;
+
+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 {
+    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>;
+
+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 ImageProps = ImageProps$1;
+
+interface CitationItem {
+    alt?: string;
+    summary?: string;
+    title?: string;
+    url: string;
+}
+
+interface SnippetProps extends FlexProps {
+    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<FlexProps, '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 {
+    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 FlexProps {
+    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 FlexProps {
+    position?: 'top' | 'bottom' | 'left' | 'right';
+    size?: number;
+    visibility?: 'auto' | 'always' | 'never';
+}
+
+declare const MaskShadow: react.NamedExoticComponent<MaskShadowProps>;
+
+interface MaterialFileTypeIconProps extends DivProps {
+    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 FlexProps {
+    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;
+    };
+    defaultOpen?: boolean;
+    defaultValue?: string;
+    enableShortKey?: boolean;
+    loading?: boolean;
+    modal?: boolean;
+    modalProps?: Omit<ModalProps, 'children' | 'open'> & {
+        onCancel?: ModalProps['onCancel'];
+    };
+    modalTitle?: ReactNode;
+    modalWidth?: number | string;
+    modalContent?: ReactNode | ((value: string, close: () => void) => ReactNode);
+    onInputChange?: (value: string) => void;
+    onOpenChange?: (open: boolean) => void;
+    onSearch?: (value: string) => void;
+    open?: boolean;
+    shortKey?: string;
+    spotlight?: boolean;
+    styles?: {
+        input?: CSSProperties;
+        shortKey?: CSSProperties;
+    };
+    value?: string;
+}
+
+declare const SearchBar: react.NamedExoticComponent<SearchBarProps>;
+
+declare const Segmented: react.NamedExoticComponent<SegmentedProps>;
+
+interface SideNavProps extends FlexProps {
+    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?: FlexProps['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<FlexProps, '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<FlexProps, '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;
+
+type TableAlign = "left" | "center" | "right";
+type TableColumnFixed = "start" | "end" | "left" | "right" | true;
+type TableColumn<TData> = {
+    key: string;
+    title: string;
+    item?: string;
+    sortable?: boolean;
+    hiddeable?: boolean;
+    width?: number | string;
+    align?: TableAlign;
+    fixed?: TableColumnFixed;
+    headerClassName?: string;
+    cellClassName?: string;
+    headerStyle?: react.CSSProperties;
+    cellStyle?: react.CSSProperties;
+    func?: (row: TData, context: {
+        value: unknown;
+        rowIndex: number;
+    }) => react.ReactNode;
+};
+type TableReadConfig<TData> = {
+    method?: "get" | "post";
+    url?: string;
+    get?: string;
+    post?: string;
+    payload?: unknown;
+    body?: unknown;
+    params?: Record<string, unknown>;
+    headers?: HeadersInit;
+    resultKey?: string;
+    mapData?: (raw: unknown) => TData[];
+    delay?: number;
+};
+type TableDataSource<TData> = {
+    bind?: TData[];
+    read?: TableReadConfig<TData>;
+};
+type TablePageSizeConfig = {
+    visible?: boolean;
+    count?: number;
+    options?: number[];
+};
+type AntdTablePropsBase<TData> = Omit<TableProps$1<TData>, "columns" | "dataSource" | "pagination">;
+interface TableProps<TData> extends AntdTablePropsBase<TData> {
+    data: TableDataSource<TData>;
+    columns: TableColumn<TData>[];
+    pagination?: boolean;
+    sortable?: boolean;
+    reload?: boolean;
+    filterable?: boolean;
+    selectable?: boolean;
+    height?: number | string;
+    rowHeight?: number;
+    overscan?: number;
+    defaultPageSize?: number;
+    pageSize?: TablePageSizeConfig;
+    className?: string;
+    emptyState?: react.ReactNode;
+    onDataChange?: (rows: TData[]) => void;
+}
+
+declare const Table: {
+    <TData extends object>({ data, columns, pagination, sortable, reload, filterable, selectable: selectableProp, height, defaultPageSize, pageSize, className, emptyState, onDataChange, loading: loadingProp, rowSelection: rowSelectionProp, rowKey: rowKeyProp, bordered: borderedProp, size: sizeProp, sticky: stickyProp, scroll: scrollProp, virtual: virtualProp, locale: localeProp, style: tableStyle, ...restTableProps }: TableProps<TData>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+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;
+};
+
+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;
+    /**
+     * Global mobile mode. Components with an `isMobile` prop will default to this value.
+     */
+    isMobile?: 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 {
+    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, CUSTOM_SELECT_CONTAINER_ATTR, 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, 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, Flex, type FlexDirection, type FlexProps, FluentEmoji, type FluentEmojiProps, FontLoader, type FontLoaderProps, Footer, type FooterProps, FormComponentImpl as Form, FormCheckbox, type FormConfig, FormDatePicker, FormError, type FormFieldRules, FormGroup, FormInput, type FormInstance, FormLabel, FormModal, type FormModalProps, type FormProps, FormSegment, FormSelect, type FormState, FormSwitch, FormTimePicker, 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, InputMask, type InputMaskProps, InputNumber, type InputNumberProps, InputOPT, type InputOPTProps, InputPassword, type InputPasswordProps, type InputProps, type ItemType, KeyMapEnum, 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, 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, SELECT_CONTAINER_ATTR, 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, SelectArrow, type SelectArrowProps, SelectBackdrop, type SelectBehaviorVariant, type SelectClassNames, SelectGroup, SelectGroupLabel, type SelectGroupLabelProps, type SelectGroupProps, SelectIcon, type SelectIconProps, type SelectIndicatorVariant, SelectItem, SelectItemIndicator, type SelectItemIndicatorProps, type SelectItemProps, SelectItemText, type SelectItemTextProps, SelectList, type SelectListProps, type SelectOption, type SelectOptionGroup, type SelectOptions, SelectPopup, type SelectPopupProps, SelectPortal, type SelectPortalProps, SelectPositioner, type SelectPositionerProps, type SelectProps, SelectRoot, SelectScrollDownArrow, type SelectScrollDownArrowProps, SelectScrollUpArrow, type SelectScrollUpArrowProps, SelectSeparator, type SelectSize, SelectTrigger, type SelectTriggerProps, SelectValue, type SelectValueProps, type SelectVariant, _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, Switch, type SwitchChangeEventHandler, type SwitchClassNames, type SwitchClickEventHandler, type SwitchContextType, SwitchIcon, type SwitchIconPosition, type SwitchIconProps, type SwitchProps, SwitchRoot, type SwitchRootProps, type SwitchSize, type SwitchStyles, SwitchThumb, type SwitchThumbProps, SyntaxHighlighter, type SyntaxHighlighterProps, SyntaxMermaid, type SyntaxMermaidProps, type SystemColorToken, Table, type TableColumn, type TableDataSource, type TablePageSizeConfig, type TableProps, type TableReadConfig, Tabs, type TabsProps, Tag, type TagProps, Text, TextArea, type TextAreaProps, type TextProps, ThemeProvider, type ThemeProviderProps, ThemeSwitch, type ThemeSwitchProps, TimePicker, type Meridiem as TimePickerMeridiem, type TimePickerProps, type TimeValue as TimePickerValue, 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, type UseFormReturn, 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 as menuSharedStyles, mermaidThemes, neutralColors, neutralColorsSwatches, placementMap, preprocessMarkdownContent, preventDefault, preventDefaultAndStopPropagation, primaryColors, primaryColorsSwatches, rehypeCustomFootnotes, rehypeKatexDir, rehypeStreamAnimated, remarkBr, remarkColor, remarkCustomFootnotes, remarkGfmPlus, remarkVideo, renderDropdownMenuItems, runRules, showContextMenu, stopPropagation, toFloatingUIPlacement, toast, updateContextMenuItems, useCdnFn, useForm, useModalContext, useMotionComponent, usePopoverContext, usePopoverPortalContainer, useSwitchContext, useToast, useTranslation };