@sia.soul/sia-react-ui 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1222 @@
+import * as react from 'react';
+import { HTMLAttributes, ReactNode, CSSProperties, ElementType, FormHTMLAttributes, InputHTMLAttributes, ChangeEvent, TextareaHTMLAttributes, MouseEvent, Key, PointerEvent, Ref, ButtonHTMLAttributes } from 'react';
+import { O as OverlayContainer, a as OverlayApiHandle } from './core-BeiAQiDY.js';
+export { B as Badge, b as BadgeProps, c as BadgeRibbonProps, d as BadgeStatus, e as Breadcrumb, f as BreadcrumbItem, g as BreadcrumbProps, h as Button, i as ButtonProps, j as ButtonSize, k as ButtonVariant, C as Calendar, l as CalendarProps, m as Card, n as CardAccent, o as CardProps, p as Carousel, q as CarouselProps, r as CarouselRef, s as Collapse, t as CollapseItem, u as CollapseKey, v as CollapseProps, D as Dropdown, w as DropdownButtonProps, x as DropdownMenuProps, y as DropdownOpenSource, z as DropdownPlacement, A as DropdownProps, E as DropdownTrigger, F as FILLED_ICON_NAMES, G as FilledIconName, H as FloatButton, I as FloatButtonBackTopProps, J as FloatButtonGroupProps, K as FloatButtonProps, L as FloatButtonShape, M as FloatingPlacement, N as FloatingTrigger, P as ICON_NAMES, Q as Icon, R as IconName, S as IconProps, T as IconVariant, U as Image, V as ImagePreview, W as ImagePreviewConfig, X as ImagePreviewProps, Y as ImageProps, Z as Input, _ as InputProps, $ as Menu, a0 as MenuClickInfo, a1 as MenuItem, a2 as MenuMode, a3 as MenuProps, a4 as MenuTheme, a5 as MessageConfig, a6 as MessageHandle, a7 as MessageKey, a8 as MessageType, a9 as Modal, aa as ModalActionResult, ab as ModalOpenConfig, ac as ModalProps, ad as ModalType, ae as NotificationConfig, af as NotificationPlacement, ag as NotificationType, ah as Popconfirm, ai as PopconfirmProps, aj as Popover, ak as PopoverProps, al as Progress, am as ProgressProps, an as ProgressStatus, ao as Rate, ap as RateProps, aq as Segmented, ar as SegmentedOption, as as SegmentedProps, at as SegmentedValue, au as Spin, av as SpinProps, aw as StepItem, ax as StepStatus, ay as Steps, az as StepsProps, aA as TabItem, aB as Tabs, aC as TabsContextMenuClickInfo, aD as TabsOrientation, aE as TabsPosition, aF as TabsProps, aG as TabsType, aH as Tag, aI as TagProps, aJ as TagStatus, aK as TagVariant, aL as Timeline, aM as TimelineItem, aN as TimelineProps, aO as Tooltip, aP as TooltipProps, aQ as Tour, aR as TourProps, aS as TourStep, aT as Tree, aU as TreeDropPosition, aV as TreeKey, aW as TreeNode, aX as TreeProps, aY as Typography, aZ as TypographyLinkProps, a_ as TypographyProps, a$ as TypographyTitleProps, b0 as TypographyType, b1 as Upload, b2 as UploadChangeInfo, b3 as UploadDraggerProps, b4 as UploadFile, b5 as UploadFileStatus, b6 as UploadProps, b7 as UploadRequestOptions, b8 as Watermark, b9 as WatermarkFont, ba as WatermarkProps, bb as message, bc as notification } from './core-BeiAQiDY.js';
+export { D as DatePicker, a as DatePickerDisabledInfo, b as DatePickerPreset, c as DatePickerProps, d as DatePickerShowTime, e as DatePickerType, f as DatePickerValue, g as DateRangePickerPreset, h as DateRangePickerProps, S as SelectDateRange, i as SelectDateRangeProps, j as SelectDateRangeValue } from './select-date-range-BDWdo7qt.js';
+import { C as ControlSize, a as ControlStatus, I as InputPlaceholderMode } from './Select-CJJ5LQap.js';
+export { S as Select, b as SelectChangeValue, c as SelectMode, d as SelectOption, e as SelectProps, f as SelectValue } from './Select-CJJ5LQap.js';
+export { RichTextContent, RichTextContentFormat, RichTextContentProps, RichTextEditor, RichTextEditorProps, RichTextImagePasteHandler, RichTextToolbar } from './rich-text-editor.js';
+export { MarkdownEditor, MarkdownEditorMode, MarkdownEditorProps } from './markdown-editor.js';
+import * as Monaco from 'monaco-editor';
+export { BaiduMapHostOptions, BaiduMapInstance, BaiduMapNamespace, BaiduMapPoint, BarChart, BarChartProps, BarDatum, BarSeries, CHART_VIEWBOX_HEIGHT, CHART_VIEWBOX_WIDTH, CandlestickChart, CandlestickChartProps, CandlestickDatum, CartesianChartProps, ChartAxis, ChartAxisProps, ChartComposite, ChartCompositeLayer, ChartCompositeProps, ChartCompositeRef, ChartDataClickInfo, ChartDataEditor, ChartDataEditorProps, ChartDataZoom, ChartDataZoomProps, ChartLegend, ChartLegendItem, ChartLegendProps, ChartMapOverlay, ChartMapOverlayProps, ChartMark, ChartMarkProps, ChartRoamController, ChartRoamControllerProps, ChartSeries, ChartTimeline, ChartTimelineProps, ChartToolbox, ChartToolboxFeature, ChartToolboxOptions, ChartToolboxProps, ChartTooltip, ChartTooltipProps, ChartValueAddress, ChartValueChannel, ChartValueIsland, ChartValueIslandProps, ChartValueTransferHandler, ChartVisualMap, ChartVisualMapProps, ChartWhirlingLoading, ChartWhirlingLoadingProps, ChordChart, ChordChartProps, ChordLink, ChordNode, DEFAULT_CHART_PALETTE, EventRiverChart, EventRiverChartProps, EventRiverEvent, EventRiverEvolution, EventRiverSeries, ForceChart, ForceGraphChart, FunnelChart, FunnelChartProps, FunnelDatum, FunnelSeries, GaugeChart, GaugeChartProps, GaugeDatum, GeoJsonFeature, GeoJsonFeatureCollection, GeoJsonMultiPolygonGeometry, GeoJsonPolygonGeometry, GraphChart, GraphChartProps, GraphLink, GraphNode, HeatmapChart, HeatmapChartProps, HeatmapPoint, KLineChart, LineChart, LineChartProps, LinePoint, LineSeries, LineShareChart, LineShareChartProps, MapChart, MapChartProps, MapDatum, MapMarkLine, MapMarkPoint, MapOverlayEvent, MapOverlayHost, MapOverlaySnapshot, MixedChart, MixedChartProps, MixedSeries, PieChart, PieChartProps, PieDatum, PieSeries, RadarChart, RadarChartProps, RadarIndicator, RadarPanel, RadarSeries, ScatterChart, ScatterChartProps, ScatterDatum, ScatterVisualMap, SiaChart, SiaChartProps, SiaChartRef, SvgMapPlot, SvgMapPlotProps, ThemeRiverChart, ThemeRiverChartProps, ThemeRiverSeries, TreeChart, TreeChartProps, TreeDatum, TreemapChart, TreemapChartProps, TreemapDatum, TreemapItemStyle, VennChart, VennChartProps, VennIntersection, VennSet, WordCloudChart, WordCloudChartProps, WordCloudDatum, XYChart, XYChartProps, XYSeries, chartColor, chartTicks, createBaiduMapHost, formatChartNumber, getChartMap, linearScale, niceChartDomain, paddedValueExtent, registerChartMap, saveCompositeImage, serializeChartStack, smoothSvgPath, svgArcPath, transferCompositeValue } from './chart.js';
+import 'vditor';
+
+type AlertStatus = "info" | "success" | "warning" | "error";
+interface AlertProps extends Omit<HTMLAttributes<HTMLDivElement>, "title"> {
+    status?: AlertStatus;
+    type?: AlertStatus;
+    title?: ReactNode;
+    message?: ReactNode;
+    description?: ReactNode;
+    action?: ReactNode;
+    showIcon?: boolean;
+    closable?: boolean;
+    closeIcon?: ReactNode;
+    banner?: boolean;
+    onClose?: (event: React.MouseEvent<HTMLButtonElement>) => void;
+    afterClose?: () => void;
+}
+declare function Alert({ status, type, title, message, description, action, showIcon, closable, closeIcon, banner, onClose, afterClose, className, ...props }: AlertProps): react.JSX.Element | null;
+
+declare const DEFAULT_PAGE_SIZE_OPTIONS: readonly [10, 25, 50, 100, 200, 500, 1000, 2000, 5000];
+interface PaginationProps extends Omit<HTMLAttributes<HTMLElement>, "onChange"> {
+    total?: number;
+    current?: number;
+    defaultCurrent?: number;
+    pageSize?: number;
+    defaultPageSize?: number;
+    pageSizeOptions?: readonly number[];
+    showSizeChanger?: boolean;
+    showTotal?: boolean | ((total: number, range: [number, number]) => ReactNode);
+    disabled?: boolean;
+    hideOnSinglePage?: boolean;
+    refreshing?: boolean;
+    onRefreshTotal?: () => void | Promise<void>;
+    onChange?: (page: number, pageSize: number) => void;
+    onShowSizeChange?: (current: number, pageSize: number) => void;
+}
+declare function Pagination({ total, current, defaultCurrent, pageSize, defaultPageSize, pageSizeOptions, showSizeChanger, showTotal, disabled, hideOnSinglePage, refreshing, onRefreshTotal, onChange, onShowSizeChange, className, ...props }: PaginationProps): react.JSX.Element | null;
+
+type CascaderValue = string | number;
+interface CascaderOption {
+    value: CascaderValue;
+    label?: ReactNode;
+    disabled?: boolean;
+    isLeaf?: boolean;
+    children?: readonly CascaderOption[];
+    [key: string]: unknown;
+}
+interface CascaderFieldNames {
+    label?: string;
+    value?: string;
+    children?: string;
+}
+interface CascaderProps extends Omit<HTMLAttributes<HTMLDivElement>, "defaultValue" | "onChange"> {
+    options: readonly CascaderOption[];
+    value?: readonly CascaderValue[] | readonly (readonly CascaderValue[])[];
+    defaultValue?: readonly CascaderValue[] | readonly (readonly CascaderValue[])[];
+    multiple?: boolean;
+    showSearch?: boolean;
+    allowClear?: boolean;
+    changeOnSelect?: boolean;
+    expandTrigger?: "click" | "hover";
+    placeholder?: ReactNode;
+    disabled?: boolean;
+    fieldNames?: CascaderFieldNames;
+    displayRender?: (labels: ReactNode[], selectedOptions: CascaderOption[]) => ReactNode;
+    loadData?: (selectedOptions: CascaderOption[]) => void | Promise<void>;
+    onChange?: (value: readonly CascaderValue[] | readonly (readonly CascaderValue[])[] | undefined, selectedOptions: CascaderOption[] | CascaderOption[][]) => void;
+}
+declare function Cascader({ options, value, defaultValue, multiple, showSearch, allowClear, changeOnSelect, expandTrigger, placeholder, disabled, fieldNames, displayRender, loadData, onChange, className, ...props }: CascaderProps): react.JSX.Element;
+
+type LayoutGap = "small" | "medium" | "large" | number | string;
+type FlexAlign = "normal" | "start" | "center" | "end" | "stretch" | "baseline";
+type FlexJustify = "normal" | "start" | "center" | "end" | "space-between" | "space-around" | "space-evenly";
+interface FlexProps extends HTMLAttributes<HTMLElement> {
+    vertical?: boolean;
+    orientation?: "horizontal" | "vertical";
+    wrap?: boolean | CSSProperties["flexWrap"];
+    justify?: FlexJustify;
+    align?: FlexAlign;
+    gap?: LayoutGap;
+    flex?: CSSProperties["flex"];
+    component?: ElementType;
+}
+declare function Flex({ vertical, orientation, wrap, justify, align, gap, flex, component: Component, className, style, ...props }: FlexProps): react.JSX.Element;
+interface SpaceProps extends HTMLAttributes<HTMLDivElement> {
+    direction?: "horizontal" | "vertical";
+    size?: LayoutGap | readonly [LayoutGap, LayoutGap];
+    align?: "start" | "center" | "end" | "baseline";
+    wrap?: boolean;
+    split?: ReactNode;
+}
+interface SpaceCompactProps extends HTMLAttributes<HTMLDivElement> {
+    direction?: "horizontal" | "vertical";
+    block?: boolean;
+}
+declare function SpaceCompact({ direction, block, className, ...props }: SpaceCompactProps): react.JSX.Element;
+declare function SpaceRoot({ direction, size, align, wrap, split, className, style, children, ...props }: SpaceProps): react.JSX.Element;
+declare const Space: typeof SpaceRoot & {
+    Compact: typeof SpaceCompact;
+};
+interface DividerProps extends HTMLAttributes<HTMLDivElement> {
+    orientation?: "horizontal" | "vertical";
+    variant?: "solid" | "dashed" | "dotted";
+    textAlign?: "start" | "center" | "end";
+    plain?: boolean;
+    children?: ReactNode;
+}
+declare function Divider({ orientation, variant, textAlign, plain, children, className, ...props }: DividerProps): react.JSX.Element;
+type GridBreakpoint = "xs" | "sm" | "md" | "lg" | "xl" | "xxl";
+type GridResponsive<T> = T | Partial<Record<GridBreakpoint, T>>;
+interface RowProps extends HTMLAttributes<HTMLDivElement> {
+    gutter?: LayoutGap | readonly [LayoutGap, LayoutGap];
+    align?: GridResponsive<"top" | "middle" | "bottom" | "stretch">;
+    justify?: GridResponsive<"start" | "end" | "center" | "space-around" | "space-between" | "space-evenly">;
+    wrap?: boolean;
+}
+declare function Row({ gutter, align, justify, wrap, className, style, ...props }: RowProps): react.JSX.Element;
+interface ColSize {
+    span?: number;
+    offset?: number;
+    order?: number;
+    push?: number;
+    pull?: number;
+}
+interface ColProps extends HTMLAttributes<HTMLDivElement>, ColSize {
+    flex?: number | string;
+    xs?: number | ColSize;
+    sm?: number | ColSize;
+    md?: number | ColSize;
+    lg?: number | ColSize;
+    xl?: number | ColSize;
+    xxl?: number | ColSize;
+}
+declare function Col({ span, offset, order, push, pull, flex, xs, sm, md, lg, xl, xxl, className, style, ...props }: ColProps): react.JSX.Element;
+
+interface SplitterPanelProps extends HTMLAttributes<HTMLDivElement> {
+    defaultSize?: number;
+    defaultCollapsed?: boolean;
+    min?: number;
+    max?: number;
+    collapsible?: boolean;
+    collapsedSize?: number;
+    collapsedContent?: ReactNode;
+    collapsedAriaLabel?: string;
+    resizable?: boolean;
+    children?: ReactNode;
+}
+interface SplitterProps extends Omit<HTMLAttributes<HTMLDivElement>, "onResize"> {
+    orientation?: "horizontal" | "vertical";
+    onResize?: (sizes: readonly number[]) => void;
+    onResizeEnd?: (sizes: readonly number[]) => void;
+}
+declare function SplitterPanel({ defaultSize: _defaultSize, defaultCollapsed: _defaultCollapsed, min: _min, max: _max, collapsible: _collapsible, collapsedSize: _collapsedSize, collapsedContent: _collapsedContent, collapsedAriaLabel: _collapsedAriaLabel, resizable: _resizable, className, ...props }: SplitterPanelProps): react.JSX.Element;
+declare function SplitterRoot({ orientation, onResize, onResizeEnd, className, children, ...props }: SplitterProps): react.JSX.Element;
+declare const Splitter: typeof SplitterRoot & {
+    Panel: typeof SplitterPanel;
+};
+
+type ToolPanelPlacement = "left" | "right";
+interface ToolPanelProps extends Omit<HTMLAttributes<HTMLDivElement>, "title" | "onResize"> {
+    title: ReactNode;
+    icon?: ReactNode;
+    placement?: ToolPanelPlacement;
+    open?: boolean;
+    defaultOpen?: boolean;
+    defaultSize?: number;
+    minSize?: number;
+    maxSize?: number;
+    onOpenChange?: (open: boolean) => void;
+    onResize?: (size: number) => void;
+    onResizeEnd?: (size: number) => void;
+}
+declare function ToolPanel({ title, icon, placement, open, defaultOpen, defaultSize, minSize, maxSize, onOpenChange, onResize, onResizeEnd, className, style, children, ...props }: ToolPanelProps): react.JSX.Element;
+
+type WindowAction = "start-dragging" | "minimize" | "toggle-maximize" | "close";
+type WindowControlAction = Exclude<WindowAction, "start-dragging">;
+type WindowActionHandler = (action: WindowAction) => void | Promise<void>;
+type WindowTitleBarActionsAlign = "left" | "right";
+interface WindowControlLabels {
+    minimize: string;
+    maximize: string;
+    restore: string;
+    close: string;
+}
+interface WindowFrameProps extends HTMLAttributes<HTMLDivElement> {
+    titleBar?: ReactNode;
+}
+interface WindowControlsProps extends HTMLAttributes<HTMLDivElement> {
+    maximized?: boolean;
+    showMinimize?: boolean;
+    showMaximize?: boolean;
+    showClose?: boolean;
+    disabledActions?: readonly WindowControlAction[];
+    labels?: Partial<WindowControlLabels>;
+    onAction?: WindowActionHandler;
+}
+interface WindowTitleBarProps extends HTMLAttributes<HTMLElement> {
+    leading?: ReactNode;
+    actions?: ReactNode;
+    actionsAlign?: WindowTitleBarActionsAlign;
+    controls?: boolean | ReactNode;
+    maximized?: boolean;
+    draggable?: boolean;
+    disabledActions?: readonly WindowControlAction[];
+    controlLabels?: Partial<WindowControlLabels>;
+    onWindowAction?: WindowActionHandler;
+}
+declare function WindowFrame({ titleBar, className, children, ...props }: WindowFrameProps): react.JSX.Element;
+declare function WindowControls({ maximized, showMinimize, showMaximize, showClose, disabledActions, labels, onAction, className, ...props }: WindowControlsProps): react.JSX.Element;
+declare function WindowTitleBar({ leading, actions, actionsAlign, controls, maximized, draggable, disabledActions, controlLabels, onWindowAction, className, children, onMouseDown, ...props }: WindowTitleBarProps): react.JSX.Element;
+
+type DrawerPlacement = "left" | "right" | "top" | "bottom";
+interface DrawerPushConfig {
+    distance?: number | string;
+}
+type DrawerPush = boolean | DrawerPushConfig;
+interface DrawerProps extends Omit<HTMLAttributes<HTMLDivElement>, "title"> {
+    open: boolean;
+    title?: ReactNode;
+    children?: ReactNode;
+    extra?: ReactNode;
+    footer?: ReactNode;
+    placement?: DrawerPlacement;
+    size?: number | string;
+    closable?: boolean;
+    maskClosable?: boolean;
+    keyboard?: boolean;
+    zIndex?: number;
+    /** 子抽屉打开时是否推移当前抽屉，默认开启。 */
+    push?: DrawerPush;
+    /** 适用于同级 Portal 渲染的多层抽屉，按层数累计推移。 */
+    pushDepth?: number;
+    getContainer?: OverlayContainer;
+    onClose?: () => void;
+    onOpenChange?: (open: boolean) => void;
+    /** 展开动画完成且面板已稳定后触发。 */
+    afterOpen?: () => void;
+    /** 关闭动画完成且面板已隐藏后触发。 */
+    afterClose?: () => void;
+}
+interface DrawerOpenConfig extends Omit<DrawerProps, "open"> {
+}
+declare function openDrawer(config: DrawerOpenConfig): OverlayApiHandle<DrawerOpenConfig>;
+declare const Drawer: react.ForwardRefExoticComponent<DrawerProps & react.RefAttributes<HTMLDivElement>> & {
+    open: typeof openDrawer;
+    destroyAll(): void;
+};
+
+type SwitchVariant = "standard" | "segmented";
+interface SwitchProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "size"> {
+    label?: ReactNode;
+    variant?: SwitchVariant;
+    checkedContent?: ReactNode;
+    uncheckedContent?: ReactNode;
+    onCheckedChange?: (checked: boolean) => void;
+}
+declare const Switch: react.ForwardRefExoticComponent<SwitchProps & react.RefAttributes<HTMLInputElement>>;
+type NamePath = string | number | readonly (string | number)[];
+type FormValues = Record<string, unknown>;
+interface FormRule {
+    required?: boolean;
+    whitespace?: boolean;
+    type?: "string" | "number" | "boolean" | "array" | "email" | "url";
+    min?: number;
+    max?: number;
+    len?: number;
+    pattern?: RegExp;
+    message?: ReactNode;
+    transform?: (value: unknown) => unknown;
+    validator?: (rule: FormRule, value: unknown, values: FormValues) => void | Promise<void>;
+}
+interface FormErrorField {
+    name: readonly (string | number)[];
+    errors: readonly ReactNode[];
+}
+interface FormInstance {
+    getFieldValue: (name: NamePath) => unknown;
+    getFieldsValue: () => FormValues;
+    getFieldError: (name: NamePath) => readonly ReactNode[];
+    setFieldValue: (name: NamePath, value: unknown) => void;
+    setFieldsValue: (values: FormValues) => void;
+    resetFields: (names?: readonly NamePath[]) => void;
+    validateFields: (names?: readonly NamePath[]) => Promise<FormValues>;
+    submit: () => void;
+    scrollToField: (name: NamePath) => void;
+}
+declare function useForm(form?: FormInstance): readonly [FormInstance];
+interface FormProps extends Omit<FormHTMLAttributes<HTMLFormElement>, "onSubmit"> {
+    form?: FormInstance;
+    initialValues?: FormValues;
+    layout?: "horizontal" | "vertical" | "inline";
+    disabled?: boolean;
+    requiredMark?: boolean | "optional";
+    onFinish?: (values: FormValues) => void;
+    onFinishFailed?: (info: {
+        values: FormValues;
+        errorFields: readonly FormErrorField[];
+    }) => void;
+    onValuesChange?: (changedValues: FormValues, values: FormValues) => void;
+}
+declare function FormRoot({ form, initialValues, layout, disabled, requiredMark, className, onFinish, onFinishFailed, onValuesChange, children, ...props }: FormProps): react.JSX.Element;
+interface FormItemProps {
+    name?: NamePath;
+    label?: ReactNode;
+    rules?: readonly FormRule[];
+    required?: boolean;
+    extra?: ReactNode;
+    help?: ReactNode;
+    validateStatus?: "success" | "warning" | "error" | "validating";
+    valuePropName?: string;
+    trigger?: string;
+    validateTrigger?: string | readonly string[];
+    getValueFromEvent?: (...args: unknown[]) => unknown;
+    noStyle?: boolean;
+    dependencies?: readonly NamePath[];
+    shouldUpdate?: boolean | ((previous: FormValues, next: FormValues) => boolean);
+    children?: ReactNode | ((form: FormInstance) => ReactNode);
+    className?: string;
+}
+declare function FormItem({ name, label, rules, required, extra, help, validateStatus, valuePropName, trigger, validateTrigger, getValueFromEvent, noStyle, children, className, }: FormItemProps): string | number | boolean | Iterable<ReactNode> | react.JSX.Element | null | undefined;
+interface FormListField {
+    key: number;
+    name: number;
+}
+interface FormListOperation {
+    add: (value?: unknown, index?: number) => void;
+    remove: (index: number | readonly number[]) => void;
+    move: (from: number, to: number) => void;
+}
+interface FormListProps {
+    name: NamePath;
+    children: (fields: readonly FormListField[], operations: FormListOperation) => ReactNode;
+}
+declare function FormList({ name, children }: FormListProps): ReactNode;
+declare function FormErrorList({ errors }: {
+    errors?: readonly ReactNode[];
+}): react.JSX.Element | null;
+declare const Form: typeof FormRoot & {
+    Item: typeof FormItem;
+    List: typeof FormList;
+    ErrorList: typeof FormErrorList;
+    useForm: typeof useForm;
+};
+
+type CheckboxValue = string | number;
+interface CheckboxProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "value" | "onChange"> {
+    value?: CheckboxValue;
+    indeterminate?: boolean;
+    children?: ReactNode;
+    onChange?: (checked: boolean, event: ChangeEvent<HTMLInputElement>) => void;
+}
+interface CheckboxOption {
+    label: ReactNode;
+    value: CheckboxValue;
+    disabled?: boolean;
+}
+interface CheckboxGroupProps {
+    value?: readonly CheckboxValue[];
+    defaultValue?: readonly CheckboxValue[];
+    options?: readonly (CheckboxOption | CheckboxValue)[];
+    disabled?: boolean;
+    name?: string;
+    className?: string;
+    children?: ReactNode;
+    onChange?: (values: readonly CheckboxValue[]) => void;
+}
+declare function CheckboxGroup({ value, defaultValue, options, disabled, name, className, children, onChange, }: CheckboxGroupProps): react.JSX.Element;
+declare const Checkbox: react.ForwardRefExoticComponent<CheckboxProps & react.RefAttributes<HTMLInputElement>> & {
+    Group: typeof CheckboxGroup;
+};
+
+type RadioValue = string | number;
+interface RadioProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "value" | "onChange"> {
+    value: RadioValue;
+    children?: ReactNode;
+    onChange?: (checked: boolean, event: ChangeEvent<HTMLInputElement>) => void;
+}
+interface RadioOption {
+    label: ReactNode;
+    value: RadioValue;
+    disabled?: boolean;
+}
+interface RadioGroupProps {
+    value?: RadioValue;
+    defaultValue?: RadioValue;
+    options?: readonly (RadioOption | RadioValue)[];
+    optionType?: "default" | "button";
+    buttonStyle?: "outline" | "solid";
+    disabled?: boolean;
+    name?: string;
+    className?: string;
+    children?: ReactNode;
+    onChange?: (value: RadioValue) => void;
+}
+declare function RadioButton(props: RadioProps): react.JSX.Element;
+declare function RadioGroup({ value, defaultValue, options, optionType, buttonStyle, disabled, name, className, children, onChange, }: RadioGroupProps): react.JSX.Element;
+declare const Radio: react.ForwardRefExoticComponent<RadioProps & {
+    button?: boolean;
+} & react.RefAttributes<HTMLInputElement>> & {
+    Button: typeof RadioButton;
+    Group: typeof RadioGroup;
+};
+
+type SliderValue = number | readonly [number, number];
+interface SliderMark {
+    label: ReactNode;
+    style?: CSSProperties;
+}
+interface SliderProps extends Omit<HTMLAttributes<HTMLDivElement>, "defaultValue" | "onChange"> {
+    value?: SliderValue;
+    defaultValue?: SliderValue;
+    min?: number;
+    max?: number;
+    step?: number;
+    range?: boolean;
+    disabled?: boolean;
+    reverse?: boolean;
+    vertical?: boolean;
+    marks?: Readonly<Record<number, ReactNode | SliderMark>>;
+    tooltip?: {
+        open?: boolean;
+        formatter?: (value: number) => ReactNode;
+    };
+    onChange?: (value: SliderValue) => void;
+    onChangeComplete?: (value: SliderValue) => void;
+}
+declare function Slider({ value, defaultValue, min, max, step, range, disabled, reverse, vertical, marks, tooltip, className, onChange, onChangeComplete, ...props }: SliderProps): react.JSX.Element;
+
+type ColorPickerMode = "solid" | "gradient";
+interface ColorPickerPreset {
+    label?: ReactNode;
+    colors: readonly string[];
+}
+interface ColorPickerProps extends Omit<HTMLAttributes<HTMLDivElement>, "defaultValue" | "onChange"> {
+    value?: string;
+    defaultValue?: string;
+    mode?: ColorPickerMode;
+    defaultMode?: ColorPickerMode;
+    modes?: readonly ColorPickerMode[];
+    disabled?: boolean;
+    allowClear?: boolean;
+    showText?: boolean | ((color: string) => ReactNode);
+    showAlpha?: boolean;
+    presets?: readonly ColorPickerPreset[];
+    onChange?: (color: string) => void;
+    onChangeComplete?: (color: string) => void;
+    onModeChange?: (mode: ColorPickerMode) => void;
+    onClear?: () => void;
+}
+declare function ColorPicker({ value, defaultValue, mode, defaultMode, modes, disabled, allowClear, showText, showAlpha, presets, className, onChange, onChangeComplete, onModeChange, onClear, ...props }: ColorPickerProps): react.JSX.Element;
+
+interface TimePickerProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "size" | "value" | "defaultValue" | "onChange"> {
+    value?: string;
+    defaultValue?: string;
+    size?: ControlSize;
+    status?: ControlStatus;
+    allowClear?: boolean;
+    use12Hours?: boolean;
+    showSecond?: boolean;
+    suffixIcon?: ReactNode;
+    disabledTime?: (value: string) => boolean;
+    onChange?: (value: string) => void;
+    onOpenChange?: (open: boolean) => void;
+}
+interface TimeRangePickerProps extends Omit<TimePickerProps, "value" | "defaultValue" | "onChange" | "placeholder"> {
+    value?: readonly [string, string];
+    defaultValue?: readonly [string, string];
+    placeholder?: readonly [string, string];
+    separator?: ReactNode;
+    onChange?: (value: readonly [string, string]) => void;
+}
+declare function TimeRangePicker({ value, defaultValue, placeholder, separator, onChange, className, style, ...props }: TimeRangePickerProps): react.JSX.Element;
+declare function TimePicker({ value, defaultValue, size, status, allowClear, use12Hours, showSecond, suffixIcon, disabledTime, disabled, readOnly, className, style, onChange, onOpenChange, placeholder, min, max, step, ...props }: TimePickerProps): react.JSX.Element;
+declare namespace TimePicker {
+    const RangePicker: typeof TimeRangePicker;
+}
+
+type TreeSelectValue = string | number;
+interface TreeSelectNode {
+    title: ReactNode;
+    value: TreeSelectValue;
+    key?: string | number;
+    disabled?: boolean;
+    selectable?: boolean;
+    children?: readonly TreeSelectNode[];
+}
+interface TreeSelectProps extends Omit<HTMLAttributes<HTMLDivElement>, "defaultValue" | "onChange"> {
+    treeData: readonly TreeSelectNode[];
+    value?: TreeSelectValue | readonly TreeSelectValue[];
+    defaultValue?: TreeSelectValue | readonly TreeSelectValue[];
+    multiple?: boolean;
+    treeCheckable?: boolean;
+    showSearch?: boolean;
+    allowClear?: boolean;
+    treeDefaultExpandAll?: boolean;
+    placeholder?: ReactNode;
+    searchPlaceholder?: string;
+    maxTagCount?: number;
+    disabled?: boolean;
+    size?: ControlSize;
+    status?: ControlStatus;
+    onChange?: (value: TreeSelectValue | readonly TreeSelectValue[] | undefined, nodes: readonly TreeSelectNode[]) => void;
+    onSearch?: (value: string) => void;
+    onDropdownVisibleChange?: (open: boolean) => void;
+}
+declare function TreeSelect({ treeData, value, defaultValue, multiple, treeCheckable, showSearch, allowClear, treeDefaultExpandAll, placeholder, searchPlaceholder, maxTagCount, disabled, size, status, className, onChange, onSearch, onDropdownVisibleChange, ...props }: TreeSelectProps): react.JSX.Element;
+
+interface TextAreaProps extends TextareaHTMLAttributes<HTMLTextAreaElement> {
+    label?: ReactNode;
+    hint?: ReactNode;
+    status?: ControlStatus;
+    showCount?: boolean;
+}
+declare const TextArea: react.ForwardRefExoticComponent<TextAreaProps & react.RefAttributes<HTMLTextAreaElement>>;
+
+type SqlDialectLanguage = "sql-postgresql" | "sql-mysql" | "sql-sqlserver" | "sql-sqlite";
+
+type EditorTheme = "light" | "dark";
+type EditorLanguage = SqlDialectLanguage | (string & {});
+interface EditorRange {
+    startLineNumber: number;
+    startColumn: number;
+    endLineNumber: number;
+    endColumn: number;
+}
+interface EditorMarker extends EditorRange {
+    message: string;
+    severity?: "error" | "warning" | "info";
+    source?: string;
+}
+interface EditorSelectionChange {
+    range: EditorRange;
+    text: string;
+    cursorOffset: number;
+}
+interface EditorKeyDownEvent {
+    key: string;
+    code: string;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    shiftKey: boolean;
+    altKey: boolean;
+    repeat: boolean;
+    preventDefault(): void;
+    stopPropagation(): void;
+}
+type EditorCompletionItemKind = "text" | "keyword" | "snippet" | "database" | "schema" | "table" | "view" | "column" | "function" | "procedure" | "value";
+interface EditorCompletionContext {
+    value: string;
+    textBeforeCursor: string;
+    lineTextBeforeCursor: string;
+    word: string;
+    position: {
+        lineNumber: number;
+        column: number;
+        offset: number;
+    };
+    triggerCharacter?: string;
+}
+interface EditorCompletionItem {
+    label: string;
+    insertText?: string;
+    kind?: EditorCompletionItemKind;
+    detail?: string;
+    documentation?: string;
+    filterText?: string;
+    sortText?: string;
+    preselect?: boolean;
+    commitCharacters?: readonly string[];
+    insertTextFormat?: "plain" | "snippet";
+    range?: EditorRange;
+}
+type EditorCompletionProvider = (context: EditorCompletionContext) => readonly EditorCompletionItem[] | Promise<readonly EditorCompletionItem[]>;
+type EditorCommand = "cut" | "copy" | "paste" | "selectAll";
+interface EditorContextMenuItem {
+    key: string;
+    label: string;
+    command?: EditorCommand;
+    shortcut?: string;
+    disabled?: boolean | ((api: EditorHandle | null) => boolean);
+    onClick?: (api: EditorHandle) => void;
+}
+interface EditorHandle {
+    focus(): void;
+    getValue(): string;
+    getSelection(): EditorRange | null;
+    getSelectedText(): string;
+    insertBlock(content: string): void;
+    prefixLines(prefix: string): void;
+    replaceValue(content: string): void;
+    revealLine(line: number): void;
+    setSelection(range: EditorRange): void;
+    wrapSelection(prefix: string, suffix: string, placeholder?: string): void;
+}
+interface EditorProps {
+    value: string;
+    onChange?: (value: string) => void;
+    onReady?: (api: EditorHandle | null) => void;
+    onSelectionChange?: (selection: EditorSelectionChange) => void;
+    onKeyDown?: (event: EditorKeyDownEvent) => void;
+    language?: EditorLanguage;
+    path?: string;
+    theme?: EditorTheme;
+    options?: Monaco.editor.IStandaloneEditorConstructionOptions;
+    highlightRange?: EditorRange | null;
+    markers?: readonly EditorMarker[];
+    contextMenuItems?: readonly EditorContextMenuItem[];
+    completionProvider?: EditorCompletionProvider;
+    completionTriggerCharacters?: readonly string[];
+    refreshSuggestionOnSpace?: boolean;
+    className?: string;
+    ariaLabel?: string;
+    loadingText?: string;
+}
+declare function Editor({ value, onChange, onReady, onSelectionChange, onKeyDown, language, path, theme, options, highlightRange, markers, contextMenuItems, completionProvider, completionTriggerCharacters, refreshSuggestionOnSpace, className, ariaLabel, loadingText, }: EditorProps): react.JSX.Element;
+
+interface MarkdownProps extends Omit<HTMLAttributes<HTMLElement>, "children"> {
+    content: string;
+    emptyText?: ReactNode;
+    resolveImageSrc?: (src: string) => string | Promise<string>;
+    imagePreview?: boolean;
+}
+declare function Markdown({ content, emptyText, resolveImageSrc, imagePreview, className, onClick, onKeyDown, ...props }: MarkdownProps): react.JSX.Element;
+
+interface InputNumberProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "defaultValue" | "onChange" | "prefix" | "size" | "type" | "value"> {
+    value?: number | null;
+    defaultValue?: number | null;
+    onChange?: (value: number | null) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    precision?: number;
+    size?: ControlSize;
+    status?: ControlStatus;
+    prefix?: ReactNode;
+    suffix?: ReactNode;
+    controls?: boolean;
+    placeholderMode?: InputPlaceholderMode;
+}
+declare const InputNumber: react.ForwardRefExoticComponent<InputNumberProps & react.RefAttributes<HTMLInputElement>>;
+
+type TreemapNodeKind = "directory" | "file";
+interface TreemapNode {
+    key: string;
+    label: string;
+    value: number;
+    kind?: TreemapNodeKind;
+    color?: string;
+    meta?: ReactNode;
+    layoutValue?: number;
+    children?: readonly TreemapNode[];
+    hasChildren?: boolean;
+    disabled?: boolean;
+}
+interface TreemapNodeClickInfo {
+    node: TreemapNode;
+    expanded: boolean;
+    nativeEvent: MouseEvent<HTMLElement>;
+}
+interface TreemapProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange"> {
+    data: readonly TreemapNode[];
+    activeKey?: string | null;
+    expandedKeys?: readonly string[];
+    defaultExpandedKeys?: readonly string[];
+    focusedKey?: string | null;
+    defaultFocusedKey?: string | null;
+    gap?: number;
+    headerHeight?: number;
+    minLabelWidth?: number;
+    minLabelHeight?: number;
+    minTileWidth?: number;
+    minTileHeight?: number;
+    maxVisibleNodes?: number;
+    emptyContent?: ReactNode;
+    valueFormatter?: (value: number, node: TreemapNode) => ReactNode;
+    overflowLabel?: (count: number) => string;
+    onExpandedChange?: (keys: string[]) => void;
+    onFocusedChange?: (key: string | null) => void;
+    onNodeClick?: (info: TreemapNodeClickInfo) => void;
+}
+declare function Treemap({ data, activeKey, expandedKeys, defaultExpandedKeys, focusedKey, defaultFocusedKey, gap, headerHeight, minLabelWidth, minLabelHeight, minTileWidth, minTileHeight, maxVisibleNodes, emptyContent, valueFormatter, overflowLabel, onExpandedChange, onFocusedChange, onNodeClick, className, style, ...props }: TreemapProps): react.JSX.Element;
+
+type TableKey = Key;
+type TableFixed = "left" | "right";
+type TableAlign = "left" | "center" | "right";
+type TableSize = "small" | "medium" | "large";
+interface TableRow<T> {
+    key: TableKey;
+    record: T;
+    sourceIndex: number;
+    depth: number;
+    meta: Record<string, unknown>;
+}
+interface TableCellRenderInfo<T> {
+    row: TableRow<T>;
+    rowIndex: number;
+    column: TableColumn<T>;
+}
+interface TableMergeStickyConfig<T> {
+    inset?: number;
+    zIndex?: number;
+    className?: string;
+    style?: CSSProperties;
+    align?: TableAlign;
+    getValue?: (record: T, index: number, rows: readonly T[]) => ReactNode;
+}
+interface TableColumn<T = Record<string, unknown>> {
+    key: string;
+    code?: string;
+    name?: string;
+    title?: ReactNode;
+    description?: ReactNode;
+    dataIndex?: keyof T | string | readonly string[];
+    width?: number;
+    flex?: number;
+    autoWidth?: boolean;
+    minWidth?: number;
+    maxWidth?: number;
+    align?: TableAlign;
+    fixed?: TableFixed | boolean;
+    hidden?: boolean;
+    ellipsis?: boolean;
+    showTitle?: boolean;
+    sortable?: boolean;
+    filterable?: boolean;
+    editable?: boolean | TableEditableCellConfig<T>;
+    exportable?: boolean;
+    exportRender?: (value: unknown, record: T, index: number, info: TableCellRenderInfo<T>) => ReactNode;
+    rowSpan?: boolean | keyof T | string | readonly string[] | ((record: T, index: number, rows: readonly T[]) => unknown);
+    mergeSticky?: boolean | TableMergeStickyConfig<T>;
+    sum?: boolean;
+    children?: readonly TableColumn<T>[];
+    render?: (value: unknown, record: T, index: number, info: TableCellRenderInfo<T>) => ReactNode;
+    renderHeader?: (column: TableColumn<T>, context: TablePluginContext<T, any>) => ReactNode;
+    cellClassName?: string | ((record: T, index: number) => string);
+    headerClassName?: string;
+    meta?: Record<string, unknown>;
+}
+type TableEditableCellType = "input" | "inputNumber" | "select" | "custom";
+interface TableEditableCellConfig<T> {
+    type?: TableEditableCellType;
+    options?: readonly {
+        label: ReactNode;
+        value: string | number;
+    }[];
+    editRender?: (record: T, save: (value: unknown) => void, cancel: () => void) => ReactNode;
+    canEdit?: (record: T) => boolean;
+}
+interface TablePluginContext<T, S = unknown> {
+    readonly pluginId: string;
+    readonly sourceData: readonly T[];
+    readonly baseColumns: readonly TableColumn<T>[];
+    readonly rows: readonly TableRow<T>[];
+    readonly columns: readonly TableColumn<T>[];
+    readonly state: S;
+    getRowKey: (record: T, index: number) => TableKey;
+    getState: <Value = unknown>(pluginId: string) => Value | undefined;
+    setState: (next: S | ((previous: S) => S)) => void;
+    setPluginState: <Value>(pluginId: string, next: Value | ((previous: Value) => Value)) => void;
+    getPluginApi: <Api = unknown>(pluginId: string) => Api | undefined;
+    emit: (event: TablePluginEvent) => void;
+}
+interface TablePluginEvent {
+    type: string;
+    source: string;
+    payload?: unknown;
+}
+interface TablePluginCellProps {
+    rowSpan?: number;
+    colSpan?: number;
+    hidden?: boolean;
+    className?: string;
+    style?: CSSProperties;
+    content?: ReactNode;
+}
+interface TablePluginHeaderCellProps {
+    className?: string;
+    style?: CSSProperties;
+}
+interface TablePlugin<T, S = unknown, Api = unknown> {
+    id: string;
+    order?: number;
+    disableVirtual?: boolean;
+    initialState?: S | (() => S);
+    transformColumns?: (columns: readonly TableColumn<T>[], context: TablePluginContext<T, S>) => readonly TableColumn<T>[];
+    transformRows?: (rows: readonly TableRow<T>[], context: TablePluginContext<T, S>) => readonly TableRow<T>[];
+    renderToolbarStart?: (context: TablePluginContext<T, S>) => ReactNode;
+    renderToolbarEnd?: (context: TablePluginContext<T, S>) => ReactNode;
+    renderSummary?: (context: TablePluginContext<T, S>) => readonly TableSummaryRow[] | null;
+    renderFooter?: (context: TablePluginContext<T, S>) => ReactNode;
+    renderOverlay?: (context: TablePluginContext<T, S>) => ReactNode;
+    getRowClassName?: (row: TableRow<T>, context: TablePluginContext<T, S>) => string;
+    getCellProps?: (row: TableRow<T>, column: TableColumn<T>, context: TablePluginContext<T, S>) => TablePluginCellProps | void;
+    getHeaderCellProps?: (column: TableColumn<T>, context: TablePluginContext<T, S>) => TablePluginHeaderCellProps | void;
+    onRowClick?: (row: TableRow<T>, context: TablePluginContext<T, S>) => void;
+    onRowMouseEnter?: (row: TableRow<T>, context: TablePluginContext<T, S>) => void;
+    onRowMouseLeave?: (row: TableRow<T>, context: TablePluginContext<T, S>) => void;
+    onCellMouseEnter?: (row: TableRow<T>, column: TableColumn<T>, context: TablePluginContext<T, S>) => void;
+    onCellMouseLeave?: (row: TableRow<T>, column: TableColumn<T>, context: TablePluginContext<T, S>) => void;
+    onCellClick?: (row: TableRow<T>, column: TableColumn<T>, event: MouseEvent<HTMLTableCellElement>, context: TablePluginContext<T, S>) => void;
+    onCellPointerDown?: (row: TableRow<T>, column: TableColumn<T>, event: PointerEvent<HTMLTableCellElement>, context: TablePluginContext<T, S>) => void;
+    onCellPointerMove?: (row: TableRow<T>, column: TableColumn<T>, event: PointerEvent<HTMLTableCellElement>, context: TablePluginContext<T, S>) => void;
+    onHeaderPointerDown?: (column: TableColumn<T>, event: PointerEvent<HTMLTableCellElement>, context: TablePluginContext<T, S>) => void;
+    onHeaderPointerMove?: (column: TableColumn<T>, event: PointerEvent<HTMLTableCellElement>, context: TablePluginContext<T, S>) => void;
+    onMount?: (context: TablePluginContext<T, S>) => void | (() => void);
+    onEvent?: (event: TablePluginEvent, context: TablePluginContext<T, S>) => void;
+    getApi?: (context: TablePluginContext<T, S>) => Api;
+}
+type AnyTablePlugin<T> = TablePlugin<T, any, any>;
+interface TableSummaryRow {
+    key: string;
+    label?: ReactNode;
+    values: Record<string, ReactNode>;
+    className?: string;
+}
+interface TableProps<T extends Record<string, unknown> = Record<string, unknown>> extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    dataSource?: readonly T[];
+    columns?: readonly TableColumn<T>[];
+    rowKey?: keyof T | string | ((record: T, index: number) => TableKey);
+    plugins?: readonly AnyTablePlugin<T>[];
+    loading?: boolean;
+    emptyText?: ReactNode;
+    height?: number | string;
+    tableHeight?: number | string;
+    size?: TableSize;
+    bordered?: boolean;
+    striped?: boolean;
+    virtual?: boolean;
+    virtualThreshold?: number;
+    rowHeight?: number;
+    overscan?: number;
+    stickyHeader?: boolean;
+    resizable?: boolean;
+    onRowClick?: (record: T, index: number) => void;
+    onRowDoubleClick?: (record: T, index: number) => void;
+    onCellContextMenu?: (record: T, column: TableColumn<T>, index: number, event: MouseEvent<HTMLTableCellElement>) => void;
+    rowClassName?: string | ((record: T, index: number) => string);
+    tableStyle?: CSSProperties;
+}
+interface TableRef<T> {
+    getRows: () => readonly T[];
+    getColumns: () => readonly TableColumn<T>[];
+    getPluginApi: <Api = unknown>(pluginId: string) => Api | undefined;
+    scrollTo: (options: ScrollToOptions) => void;
+    setLoading: (loading: boolean) => void;
+    getPage: () => {
+        current: number;
+        pageSize: number;
+    };
+    setPage: (page: Partial<{
+        current: number;
+        pageSize: number;
+    }>) => void;
+    clearSelection: () => void;
+    setSelectedKeys: (keys: readonly TableKey[]) => void;
+    getSelectedRows: () => readonly T[];
+    getSortInfo: () => TableSortInfo | null;
+    getColumnSettings: () => readonly TableColumnSettingItem[];
+    openColumnSetting: () => void;
+    generatePageParams: <Model extends Record<string, unknown>>(model: Model) => Model & TablePageParams;
+    requestCount: (model?: unknown) => Promise<void>;
+}
+interface TableSortInfo {
+    field: string;
+    order: "ascend" | "descend" | null;
+    scope?: "page" | "all";
+}
+interface TablePageParams {
+    current: number;
+    pageIndex: number;
+    pageSize: number;
+    skipCount: number;
+    maxResultCount: number;
+}
+interface TableColumnSettingItem {
+    key: string;
+    width?: number;
+    fixed?: TableFixed;
+    visible: boolean;
+    order: number;
+}
+interface TableSettingsSnapshot {
+    columns?: readonly TableColumnSettingItem[];
+    pageSize?: number;
+    version?: number;
+}
+interface TableSettingsAdapter {
+    load: (scope: {
+        moduleName: string;
+        businessKey: string;
+    }) => Promise<TableSettingsSnapshot | null>;
+    save: (scope: {
+        moduleName: string;
+        businessKey: string;
+    }, settings: TableSettingsSnapshot) => Promise<void>;
+}
+
+declare const Table: <T extends Record<string, unknown> = Record<string, unknown>>(props: TableProps<T> & {
+    ref?: Ref<TableRef<T>>;
+}) => ReactNode;
+
+interface TableColumnTransformPluginOptions<T> {
+    prepend?: readonly TableColumn<T>[];
+    append?: readonly TableColumn<T>[];
+    transform?: (columns: readonly TableColumn<T>[]) => readonly TableColumn<T>[];
+}
+declare function createColumnTransformPlugin<T extends Record<string, unknown>>(options: TableColumnTransformPluginOptions<T>): TablePlugin<T, undefined>;
+type TableHighlightValue = boolean | CSSProperties;
+interface TableHighlightPluginOptions {
+    row?: TableHighlightValue;
+    column?: TableHighlightValue;
+    cell?: TableHighlightValue;
+}
+interface HighlightState {
+    rowKey?: TableKey;
+    columnKey?: string;
+}
+declare function createHighlightPlugin<T extends Record<string, unknown>>(options?: TableHighlightPluginOptions): TablePlugin<T, HighlightState>;
+interface TableCellAddress {
+    rowKey: TableKey;
+    columnKey: string;
+}
+interface TableCellRange {
+    anchor: TableCellAddress;
+    focus: TableCellAddress;
+}
+interface TableSelectedCell<T> {
+    rowKey: TableKey;
+    columnKey: string;
+    record: T;
+    column: TableColumn<T>;
+    value: unknown;
+    rowIndex: number;
+    columnIndex: number;
+}
+interface TableCellSelectionPluginOptions<T> {
+    defaultRange?: TableCellRange | null;
+    includeUtilityColumns?: boolean;
+    copyable?: boolean;
+    isCellSelectable?: (record: T, column: TableColumn<T>, rowIndex: number, columnIndex: number) => boolean;
+    onChange?: (range: TableCellRange | null, cells: readonly TableSelectedCell<T>[]) => void;
+    onCopy?: (text: string, cells: readonly TableSelectedCell<T>[]) => void;
+}
+interface CellSelectionState {
+    range: TableCellRange | null;
+    includeHeaders: boolean;
+    selectedHeaderKey: string | null;
+}
+interface TableCellSelectionApi<T> {
+    getRange: () => TableCellRange | null;
+    setRange: (range: TableCellRange | null) => void;
+    clear: () => void;
+    getSelectedCells: () => readonly TableSelectedCell<T>[];
+    getCopyText: () => string;
+}
+declare function createCellSelectionPlugin<T extends Record<string, unknown>>(options?: TableCellSelectionPluginOptions<T>): TablePlugin<T, CellSelectionState, TableCellSelectionApi<T>>;
+interface TableRowSpanPluginOptions<T> {
+    columns?: readonly string[];
+    equals?: (left: unknown, right: unknown, column: TableColumn<T>) => boolean;
+    disableVirtual?: boolean;
+}
+declare function createRowSpanPlugin<T extends Record<string, unknown>>(options?: TableRowSpanPluginOptions<T>): TablePlugin<T, undefined>;
+type TableSelectionMode = "single" | "multiple" | "row";
+interface TableSelectionPluginOptions<T> {
+    mode?: TableSelectionMode;
+    selectedKeys?: readonly TableKey[];
+    defaultSelectedKeys?: readonly TableKey[];
+    onChange?: (keys: readonly TableKey[], rows: readonly T[]) => void;
+    getCheckboxDisabled?: (record: T) => boolean;
+    showSelectedCount?: boolean;
+    preserveSelectedRowKeys?: boolean;
+    showPreserveSelectedRowKeys?: boolean;
+    selectionPanelColumnCount?: number;
+    selectionPanelMaxCount?: number;
+    onPreserveSelectedRowKeysChange?: (preserve: boolean) => void;
+    childrenColumnName?: string;
+}
+interface SelectionState {
+    selectedKeys: readonly TableKey[];
+    preserveSelectedRowKeys: boolean;
+    panelOpen: boolean;
+}
+interface TableSelectionApi<T> {
+    getSelectedKeys: () => readonly TableKey[];
+    setSelectedKeys: (keys: readonly TableKey[]) => void;
+    clear: () => void;
+    toggle: (key: TableKey, checked?: boolean) => void;
+    getSelectedRows: () => readonly T[];
+    getPreserveSelectedRowKeys: () => boolean;
+    setPreserveSelectedRowKeys: (preserve: boolean) => void;
+}
+declare function createSelectionPlugin<T extends Record<string, unknown>>(options?: TableSelectionPluginOptions<T>): TablePlugin<T, SelectionState, TableSelectionApi<T>>;
+interface TableSortPluginOptions {
+    mode?: "local" | "remote";
+    scope?: "page" | "all";
+    value?: TableSortInfo | null;
+    defaultValue?: TableSortInfo | null;
+    onChange?: (sort: TableSortInfo) => void;
+    compare?: (a: unknown, b: unknown, field: string) => number;
+}
+interface SortState {
+    sort: TableSortInfo | null;
+}
+interface TableSortApi {
+    getSortInfo: () => TableSortInfo | null;
+    setSortInfo: (sort: TableSortInfo | null) => void;
+    clear: () => void;
+}
+declare function createSortPlugin<T extends Record<string, unknown>>(options?: TableSortPluginOptions): TablePlugin<T, SortState, TableSortApi>;
+type TableFilterValues = Readonly<Record<string, string>>;
+interface TableFilterPluginOptions<T> {
+    value?: TableFilterValues;
+    defaultValue?: TableFilterValues;
+    placeholder?: string | ((column: TableColumn<T>) => string);
+    predicate?: (value: unknown, filterValue: string, record: T, column: TableColumn<T>) => boolean;
+    onChange?: (filters: TableFilterValues) => void;
+}
+interface FilterState {
+    filters: Record<string, string>;
+}
+interface TableFilterApi<T> {
+    getFilters: () => TableFilterValues;
+    setFilter: (columnKey: string, value: string) => void;
+    clear: (columnKey?: string) => void;
+    getFilteredRows: () => readonly T[];
+}
+declare function createFilterPlugin<T extends Record<string, unknown>>(options?: TableFilterPluginOptions<T>): TablePlugin<T, FilterState, TableFilterApi<T>>;
+interface TablePaginationPluginOptions {
+    mode?: "local" | "server" | "auto";
+    totalCount?: number;
+    current?: number;
+    pageSize?: number;
+    defaultCurrent?: number;
+    defaultPageSize?: number;
+    pageSizeOptions?: readonly number[];
+    onChange?: (current: number, pageSize: number, isFirstLoad?: boolean) => void;
+    requestTotal?: (model?: unknown) => Promise<void>;
+    isFirstLoad?: boolean;
+}
+interface PaginationState {
+    current: number;
+    pageSize: number;
+    requestLoading: boolean;
+}
+interface TablePaginationApi {
+    getPage: () => {
+        current: number;
+        pageSize: number;
+    };
+    setPage: (page: Partial<{
+        current: number;
+        pageSize: number;
+    }>) => void;
+    generatePageParams: <Model extends Record<string, unknown>>(model: Model) => Model & TablePageParams;
+    requestCount: (model?: unknown) => Promise<void>;
+}
+declare function createPaginationPlugin<T extends Record<string, unknown>>(options?: TablePaginationPluginOptions): TablePlugin<T, PaginationState, TablePaginationApi>;
+interface TableIndexPluginOptions {
+    title?: ReactNode;
+    width?: number;
+    startIndex?: number;
+}
+declare function createIndexPlugin<T extends Record<string, unknown>>(options?: TableIndexPluginOptions): TablePlugin<T, undefined>;
+interface TableTreePluginOptions<T> {
+    childrenColumnName?: string;
+    ignoreChildrenColumn?: boolean;
+    expandedRowKeys?: readonly TableKey[];
+    defaultExpandedRowKeys?: readonly TableKey[];
+    defaultExpandAllRows?: boolean;
+    onExpandedRowsChange?: (keys: readonly TableKey[]) => void;
+    canExpand?: (record: T) => boolean;
+}
+interface TreeState {
+    expandedKeys: readonly TableKey[];
+}
+interface TableTreeApi {
+    getExpandedKeys: () => readonly TableKey[];
+    setExpandedKeys: (keys: readonly TableKey[]) => void;
+    expandAll: () => void;
+    collapseAll: () => void;
+}
+declare function createTreePlugin<T extends Record<string, unknown>>(options?: TableTreePluginOptions<T>): TablePlugin<T, TreeState, TableTreeApi>;
+interface TableSummaryPluginOptions<T> {
+    subTotal?: Record<string, ReactNode> | ((pageData: readonly T[]) => Record<string, ReactNode>);
+    total?: Record<string, ReactNode>;
+    subTotalLabel?: ReactNode;
+    totalLabel?: ReactNode;
+}
+declare function createSummaryPlugin<T extends Record<string, unknown>>(options: TableSummaryPluginOptions<T>): TablePlugin<T, undefined>;
+interface EditableState {
+    editing: {
+        rowKey: TableKey;
+        columnKey: string;
+    } | null;
+}
+interface TableEditablePluginOptions<T> {
+    onCellChange?: (columnKey: string, record: T, newValue: unknown) => boolean | Promise<boolean>;
+    trigger?: "click" | "doubleClick";
+}
+interface TableEditableApi {
+    cancel: () => void;
+    getEditingCell: () => EditableState["editing"];
+}
+declare function createEditablePlugin<T extends Record<string, unknown>>(options?: TableEditablePluginOptions<T>): TablePlugin<T, EditableState, TableEditableApi>;
+interface ResizeState {
+    widths: Record<string, number>;
+    manualLayout?: boolean;
+}
+interface TableResizePluginOptions {
+    enabled?: boolean;
+    onResize?: (columnKey: string, width: number) => void;
+}
+interface TableResizeApi {
+    getWidths: () => Readonly<Record<string, number>>;
+    setWidth: (columnKey: string, width: number) => void;
+}
+declare function createResizePlugin<T extends Record<string, unknown>>(options?: TableResizePluginOptions): TablePlugin<T, ResizeState, TableResizeApi>;
+interface TableColumnSettingPluginOptions<T> {
+    defaultVisibleKeys?: readonly string[];
+    showButton?: boolean;
+    onVisibleChange?: (columns: readonly TableColumn<T>[]) => void;
+    onOrderChange?: (columns: readonly TableColumn<T>[]) => void;
+    adapter?: TableSettingsAdapter;
+    scope?: {
+        moduleName: string;
+        businessKey: string;
+    };
+}
+interface ColumnSettingState {
+    open: boolean;
+    items: readonly TableColumnSettingItem[];
+    loaded: boolean;
+    pageSize?: number;
+}
+interface TableColumnSettingApi {
+    open: () => void;
+    close: () => void;
+    getSettings: () => readonly TableColumnSettingItem[];
+    apply: (settings: readonly TableColumnSettingItem[]) => void;
+}
+declare function createColumnSettingPlugin<T extends Record<string, unknown>>(options?: TableColumnSettingPluginOptions<T>): TablePlugin<T, ColumnSettingState, TableColumnSettingApi>;
+declare function createLocalStorageTableSettingsAdapter(prefix?: string): TableSettingsAdapter;
+interface TableToolbarItem<T> {
+    key: string;
+    label: ReactNode;
+    icon?: ReactNode;
+    position?: "start" | "end";
+    inSettings?: boolean;
+    danger?: boolean;
+    disabled?: boolean | ((context: TablePluginContext<T, any>) => boolean);
+    hidden?: boolean | ((context: TablePluginContext<T, any>) => boolean);
+    onClick?: (context: TablePluginContext<T, any>) => void | Promise<void>;
+}
+interface TableToolbarPluginOptions<T> {
+    start?: ReactNode;
+    end?: ReactNode;
+    items?: readonly TableToolbarItem<T>[];
+    canAccess?: (item: TableToolbarItem<T>) => boolean;
+}
+declare function createToolbarPlugin<T extends Record<string, unknown>>(options: TableToolbarPluginOptions<T>): TablePlugin<T, undefined>;
+type TableExportScope = "visible" | "all" | "selected";
+interface TableExportPluginOptions<T> {
+    scope?: TableExportScope;
+    fileName?: string | ((context: TablePluginContext<T, undefined>) => string);
+    delimiter?: "," | "\t" | ";";
+    includeBom?: boolean;
+    sanitizeFormula?: boolean;
+    buttonLabel?: ReactNode;
+    showButton?: boolean;
+    onExport?: (csv: string, rows: readonly T[]) => void | Promise<void>;
+}
+interface TableExportApi<T> {
+    getCsv: (scope?: TableExportScope) => string;
+    download: (scope?: TableExportScope) => Promise<void>;
+    getRows: (scope?: TableExportScope) => readonly T[];
+}
+declare function createExportPlugin<T extends Record<string, unknown>>(options?: TableExportPluginOptions<T>): TablePlugin<T, undefined, TableExportApi<T>>;
+
+interface ThemeSwitchProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, "onChange"> {
+    checked: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    lightLabel?: string;
+    darkLabel?: string;
+}
+declare const ThemeSwitch: react.ForwardRefExoticComponent<ThemeSwitchProps & react.RefAttributes<HTMLButtonElement>>;
+
+interface FloatingScrollbarProviderProps {
+    disabled?: boolean;
+}
+declare function FloatingScrollbarProvider({ disabled }: FloatingScrollbarProviderProps): null;
+
+type SiaThemeMode = "light" | "dark";
+declare const SIA_THEME: {
+    readonly colorPrimary: "#1677ff";
+    readonly colorPrimaryHover: "#4096ff";
+    readonly colorPrimaryActive: "#0958d9";
+    readonly colorText: "#1f1f1f";
+    readonly colorTextSecondary: "#666666";
+    readonly colorBackground: "#f5f7fa";
+    readonly colorSurface: "#ffffff";
+    readonly colorBorder: "#d9d9d9";
+    readonly borderRadius: 6;
+    readonly controlHeight: 32;
+    readonly spacing: 16;
+    readonly fontSize: 16;
+    readonly fontSizeSmall: 14;
+    readonly fontSizeLarge: 18;
+};
+declare function applySiaTheme(mode: SiaThemeMode, target?: HTMLElement): void;
+
+export { Alert, type AlertProps, type AlertStatus, type AnyTablePlugin, Cascader, type CascaderFieldNames, type CascaderOption, type CascaderProps, type CascaderValue, Checkbox, type CheckboxGroupProps, type CheckboxOption, type CheckboxProps, type CheckboxValue, Col, type ColProps, type ColSize, ColorPicker, type ColorPickerMode, type ColorPickerPreset, type ColorPickerProps, ControlSize, ControlStatus, DEFAULT_PAGE_SIZE_OPTIONS, Divider, type DividerProps, Drawer, type DrawerOpenConfig, type DrawerPlacement, type DrawerProps, type DrawerPush, type DrawerPushConfig, Editor, type EditorCommand, type EditorCompletionContext, type EditorCompletionItem, type EditorCompletionItemKind, type EditorCompletionProvider, type EditorContextMenuItem, type EditorHandle, type EditorKeyDownEvent, type EditorLanguage, type EditorMarker, type EditorProps, type EditorRange, type EditorSelectionChange, type EditorTheme, Flex, type FlexProps, FloatingScrollbarProvider, type FloatingScrollbarProviderProps, Form, type FormErrorField, type FormInstance, type FormItemProps, type FormListField, type FormListOperation, type FormListProps, type FormProps, type FormRule, type FormValues, type GridBreakpoint, InputNumber, type InputNumberProps, InputPlaceholderMode, type LayoutGap, Markdown, type MarkdownProps, type NamePath, OverlayApiHandle, Pagination, type PaginationProps, Radio, type RadioGroupProps, type RadioOption, type RadioProps, type RadioValue, Row, type RowProps, SIA_THEME, type SiaThemeMode, Slider, type SliderMark, type SliderProps, type SliderValue, Space, type SpaceCompactProps, type SpaceProps, Splitter, type SplitterPanelProps, type SplitterProps, Switch, type SwitchProps, type SwitchVariant, Table, type TableAlign, type TableCellAddress, type TableCellRange, type TableCellRenderInfo, type TableCellSelectionApi, type TableCellSelectionPluginOptions, type TableColumn, type TableColumnSettingApi, type TableColumnSettingItem, type TableColumnSettingPluginOptions, type TableColumnTransformPluginOptions, type TableEditableApi, type TableEditableCellConfig, type TableEditableCellType, type TableEditablePluginOptions, type TableExportApi, type TableExportPluginOptions, type TableExportScope, type TableFilterApi, type TableFilterPluginOptions, type TableFilterValues, type TableFixed, type TableHighlightPluginOptions, type TableHighlightValue, type TableIndexPluginOptions, type TableKey, type TableMergeStickyConfig, type TablePageParams, type TablePaginationApi, type TablePaginationPluginOptions, type TablePlugin, type TablePluginCellProps, type TablePluginContext, type TablePluginEvent, type TableProps, type TableRef, type TableResizeApi, type TableResizePluginOptions, type TableRow, type TableRowSpanPluginOptions, type TableSelectedCell, type TableSelectionApi, type TableSelectionMode, type TableSelectionPluginOptions, type TableSettingsAdapter, type TableSettingsSnapshot, type TableSize, type TableSortApi, type TableSortInfo, type TableSortPluginOptions, type TableSummaryPluginOptions, type TableSummaryRow, type TableToolbarItem, type TableToolbarPluginOptions, type TableTreeApi, type TableTreePluginOptions, TextArea, type TextAreaProps, ThemeSwitch, type ThemeSwitchProps, TimePicker, type TimePickerProps, type TimeRangePickerProps, ToolPanel, type ToolPanelPlacement, type ToolPanelProps, TreeSelect, type TreeSelectNode, type TreeSelectProps, type TreeSelectValue, Treemap, type TreemapNode, type TreemapNodeClickInfo, type TreemapNodeKind, type TreemapProps, type WindowAction, type WindowActionHandler, type WindowControlAction, type WindowControlLabels, WindowControls, type WindowControlsProps, WindowFrame, type WindowFrameProps, WindowTitleBar, type WindowTitleBarActionsAlign, type WindowTitleBarProps, applySiaTheme, createCellSelectionPlugin, createColumnSettingPlugin, createColumnTransformPlugin, createEditablePlugin, createExportPlugin, createFilterPlugin, createHighlightPlugin, createIndexPlugin, createLocalStorageTableSettingsAdapter, createPaginationPlugin, createResizePlugin, createRowSpanPlugin, createSelectionPlugin, createSortPlugin, createSummaryPlugin, createToolbarPlugin, createTreePlugin, useForm };