bj-web-components 0.2.12 → 0.2.14

package/README.md

@@ -19,6 +19,44 @@ import { SkuInputCard } from 'bu-max-ui';
 import 'bu-max-ui/style';
 ```
 
+## Iconfont 图标
+
+Web 组件中的图标使用 `BuIcon`（与下方 `Iconfont` 实现等价）。宿主应用或文档站需要先加载项目 iconfont symbol：
+
+```html
+<script src="//at.alicdn.com/t/c/font_5123795_8zzfaepwkju.js"></script>
+```
+
+随后通过 `type` 传入 symbol id（不包含 `#`）：
+
+```tsx
+import { BuIcon } from 'bu-max-ui/web';
+
+<BuIcon type="icon-a-dagouxi" style={{ width: 14, height: 14, color: '#333' }} />
+```
+
+`BuIcon` 的实现如下：
+
+```tsx
+import React from 'react';
+
+function Iconfont({ type, style, onClick, className, ...rest }) {
+  return (
+    <svg
+      style={style}
+      className={className ? `icon ${className}` : 'icon'}
+      aria-hidden="true"
+      onClick={onClick}
+      {...rest}
+    >
+      <use xlinkHref={`#${type}`} />
+    </svg>
+  );
+}
+
+export default Iconfont;
+```
+
 ### 基础用法
 
 ```tsx

package/dist/index.d.ts

@@ -1,13 +1,21 @@
 import { CSSProperties } from 'react';
 import { FocusEvent as FocusEvent_2 } from 'react';
+import { FocusEventHandler } from 'react';
 import { ForwardRefExoticComponent } from 'react';
+import { HTMLAttributes } from 'react';
 import { InputHTMLAttributes } from 'react';
 import { JSX } from 'react/jsx-runtime';
+import { Key } from 'react';
 import { KeyboardEvent as KeyboardEvent_2 } from 'react';
+import { KeyboardEventHandler } from 'react';
 import { MouseEventHandler } from 'react';
+import { ReactElement } from 'react';
 import { ReactNode } from 'react';
+import { Ref } from 'react';
 import { RefAttributes } from 'react';
+import { RefObject } from 'react';
 import { SVGProps } from 'react';
+import { TdHTMLAttributes } from 'react';
 
 declare interface BaseTooltipProps {
     placement?: TooltipPlacement;
@@ -15,6 +23,105 @@ declare interface BaseTooltipProps {
     style?: CSSProperties;
     /** 自定义弹层挂载容器，默认 document.body */
     getPopupContainer?: () => HTMLElement;
+    /** Optional element used as the positioning anchor when rendered through a portal. */
+    getAnchorElement?: () => HTMLElement | null;
+}
+
+export declare const BCheckBox: typeof BCheckBox_2 & {
+    Group: typeof Group;
+    __ANT_CHECKBOX: boolean;
+};
+
+declare const BCheckBox_2: ForwardRefExoticComponent<BCheckBoxProps & RefAttributes<HTMLInputElement>>;
+
+export declare interface BCheckBoxGroupProps {
+    className?: string;
+    style?: CSSProperties;
+    name?: string;
+    options?: Array<CheckboxOptionType | string | number>;
+    disabled?: boolean;
+    defaultValue?: CheckboxValueType[];
+    value?: CheckboxValueType[];
+    onChange?: (checkedValues: CheckboxValueType[]) => void;
+    children?: ReactNode;
+    direction?: 'ltr' | 'rtl';
+    variant?: BCheckBoxVariant;
+}
+
+export declare interface BCheckBoxProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'checked' | 'children' | 'defaultChecked' | 'onChange' | 'onClick' | 'onMouseEnter' | 'onMouseLeave' | 'style' | 'type' | 'value'> {
+    className?: string;
+    style?: CSSProperties;
+    defaultChecked?: boolean;
+    checked?: boolean;
+    disabled?: boolean;
+    indeterminate?: boolean;
+    onChange?: (event: CheckboxChangeEvent) => void;
+    onClick?: MouseEventHandler<HTMLInputElement>;
+    onMouseEnter?: MouseEventHandler<HTMLLabelElement>;
+    onMouseLeave?: MouseEventHandler<HTMLLabelElement>;
+    onFocus?: FocusEventHandler<HTMLInputElement>;
+    onBlur?: FocusEventHandler<HTMLInputElement>;
+    onKeyDown?: KeyboardEventHandler<HTMLInputElement>;
+    onKeyPress?: KeyboardEventHandler<HTMLInputElement>;
+    onKeyUp?: KeyboardEventHandler<HTMLInputElement>;
+    value?: CheckboxValueType;
+    children?: ReactNode;
+    skipGroup?: boolean;
+    direction?: 'ltr' | 'rtl';
+    variant?: BCheckBoxVariant;
+}
+
+export declare type BCheckBoxVariant = 'dark' | 'white';
+
+export declare function BDropdown({ className, style, options, value, defaultValue, multiple, optionMode, searchable, searchValue, searchPlaceholder, onSearch, filterOption, emptyText, labels, t, optionRender, onChange, footer, showReset, showConfirm, resetText, confirmText, onReset, onConfirm, }: BDropdownProps): JSX.Element;
+
+export declare interface BDropdownOption {
+    label: ReactNode;
+    /** Secondary text displayed when optionMode is "double-line". */
+    description?: ReactNode;
+    value: BDropdownValue;
+    disabled?: boolean;
+}
+
+export declare interface BDropdownProps {
+    className?: string;
+    style?: CSSProperties;
+    options: BDropdownOption[];
+    value?: BDropdownValue[];
+    defaultValue?: BDropdownValue[];
+    multiple?: boolean;
+    /** Option layout. Double-line options display label and description. */
+    optionMode?: 'single-line' | 'double-line';
+    searchable?: boolean;
+    searchValue?: string;
+    searchPlaceholder?: string;
+    onSearch?: (value: string) => void;
+    filterOption?: boolean | ((input: string, option: BDropdownOption) => boolean);
+    /** Empty-state content. Takes precedence over labels.emptyText. */
+    emptyText?: ReactNode;
+    /** Override default labels for i18n support. */
+    labels?: {
+        emptyText?: ReactNode;
+    };
+    /** Internationalization function. Defaults to returning the original text. */
+    t?: (text: string) => string;
+    optionRender?: (option: BDropdownOption) => ReactNode;
+    onChange?: (value: BDropdownValue[], option: BDropdownOption) => void;
+    footer?: boolean | ReactNode;
+    showReset?: boolean;
+    showConfirm?: boolean;
+    resetText?: ReactNode;
+    confirmText?: ReactNode;
+    onReset?: () => void;
+    onConfirm?: (value: BDropdownValue[]) => void;
+}
+
+export declare type BDropdownValue = string | number | boolean;
+
+export declare const BInput: ForwardRefExoticComponent<BInputProps & RefAttributes<BInputRef>>;
+
+export declare interface BInputFocusOptions extends FocusOptions {
+    cursor?: 'start' | 'end' | 'all';
 }
 
 export declare const BInputNumber: ForwardRefExoticComponent<BInputNumberProps & RefAttributes<HTMLInputElement>>;
@@ -81,6 +188,112 @@ export declare type BInputNumberSize = 'small' | 'middle' | 'large';
 
 export declare type BInputNumberStatus = 'error' | 'warning';
 
+export declare interface BInputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'size' | 'prefix' | 'value'> {
+    value?: InputHTMLAttributes<HTMLInputElement>['value'] | bigint;
+    prefix?: ReactNode;
+    suffix?: ReactNode;
+    addonBefore?: ReactNode;
+    addonAfter?: ReactNode;
+    allowClear?: boolean | {
+        clearIcon?: ReactNode;
+    };
+    size?: BInputSize;
+    status?: BInputStatus;
+    bordered?: boolean;
+    htmlSize?: number;
+    onPressEnter?: KeyboardEventHandler<HTMLInputElement>;
+    onClear?: () => void;
+    className?: string;
+    style?: CSSProperties;
+}
+
+export declare interface BInputRef {
+    focus: (options?: BInputFocusOptions) => void;
+    blur: () => void;
+    setSelectionRange: HTMLInputElement['setSelectionRange'];
+    select: () => void;
+    input: HTMLInputElement | null;
+    nativeElement: HTMLElement | null;
+}
+
+export declare type BInputSize = 'small' | 'middle' | 'large';
+
+export declare type BInputStatus = 'error' | 'warning';
+
+export declare function BOverlayScrollbar({ containerRef, targetRef, selector, direction, size, gap, background, showOnHover, showOnScroll, hoverSelector, horizontalInsetStart, horizontalInsetEnd, horizontalThumbLength, className, }: BOverlayScrollbarProps): JSX.Element;
+
+export declare interface BOverlayScrollbarProps {
+    containerRef: RefObject<HTMLElement | null>;
+    targetRef?: RefObject<HTMLElement | null>;
+    selector?: string;
+    direction?: OverlayScrollbarDirection;
+    size?: number;
+    gap?: number;
+    background?: CSSProperties['backgroundColor'];
+    showOnHover?: boolean;
+    showOnScroll?: boolean;
+    hoverSelector?: string;
+    horizontalInsetStart?: number;
+    horizontalInsetEnd?: number;
+    horizontalThumbLength?: number;
+    className?: string;
+}
+
+export declare type Breakpoint = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
+
+export declare const BTable: typeof BTable_2 & {
+    Column: typeof Column;
+    ColumnGroup: typeof ColumnGroup;
+};
+
+declare function BTable_2<RecordType extends object>({ columns, dataSource, rowKey, rowSelection, pagination, loading, bordered, size, showHeader, emptyText, emptyImage, emptyHeight, t, className, style, rowClassName, sortDirections, onChange, children, title, footer, summary, tableLayout, components, onRow, onHeaderRow, id, scroll, locale, }: TableProps<RecordType>): JSX.Element;
+
+export declare function BTabs({ activeKey, children, centered, className, defaultActiveKey, id, items, onChange, onTabClick, style, tabBarGutter, tabBarStyle, tabPosition, type, }: BTabsProps): JSX.Element;
+
+export declare namespace BTabs {
+    var TabPane: TabPane;
+}
+
+export declare interface BTabsItem {
+    key: string;
+    label: ReactNode;
+    children?: ReactNode;
+    disabled?: boolean;
+    forceRender?: boolean;
+    className?: string;
+    style?: CSSProperties;
+}
+
+export declare type BTabsPosition = 'top' | 'right' | 'bottom' | 'left';
+
+export declare interface BTabsProps {
+    activeKey?: string;
+    defaultActiveKey?: string;
+    items?: BTabsItem[];
+    children?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+    id?: string;
+    tabPosition?: BTabsPosition;
+    type?: BTabsType;
+    centered?: boolean;
+    tabBarGutter?: number;
+    tabBarStyle?: CSSProperties;
+    onChange?: (activeKey: string) => void;
+    onTabClick?: (activeKey: string, event: React.MouseEvent<HTMLButtonElement>) => void;
+}
+
+export declare interface BTabsTabPaneProps extends Omit<BTabsItem, 'key' | 'label'> {
+    tab: ReactNode;
+    tabKey?: Key;
+}
+
+export declare type BTabsType = 'line' | 'card';
+
+declare function BTooltip({ placement, content, variant, className, style, getPopupContainer, getAnchorElement, color, fontColor, }: ContentTooltipProps): JSX.Element;
+export { BTooltip }
+export { BTooltip as ContentTooltip }
+
 export declare function BuCategoryDropdown({ data, value, onChange, placeholder, disabled, maxVisible, className, style, getPopupContainer, dropdownStyle: customDropdownStyle, }: BuCategoryDropdownProps): JSX.Element;
 
 export declare interface BuCategoryDropdownProps {
@@ -342,6 +555,135 @@ export declare interface CategoryItem {
     children?: CategoryItem[];
 }
 
+export declare interface CellType<RecordType> {
+    key?: Key;
+    className?: string;
+    style?: CSSProperties;
+    children?: ReactNode;
+    column?: ColumnsType<RecordType>[number];
+    colSpan?: number;
+    rowSpan?: number;
+}
+
+export declare interface CheckboxChangeEvent {
+    target: CheckboxChangeEventTarget;
+    stopPropagation: () => void;
+    preventDefault: () => void;
+    nativeEvent: Event;
+}
+
+export declare interface CheckboxChangeEventTarget extends BCheckBoxProps {
+    checked: boolean;
+}
+
+export declare interface CheckboxOptionType {
+    label: ReactNode;
+    value: CheckboxValueType;
+    style?: CSSProperties;
+    disabled?: boolean;
+    onChange?: (event: CheckboxChangeEvent) => void;
+}
+
+export declare type CheckboxValueType = string | number | boolean;
+
+export declare function Column<RecordType>(_: ColumnProps<RecordType>): null;
+
+export declare interface ColumnFilterItem {
+    text: ReactNode;
+    /** Secondary text forwarded to the built-in BDropdown in double-line mode. */
+    description?: ReactNode;
+    value: TableKey | boolean;
+    children?: ColumnFilterItem[];
+}
+
+export declare function ColumnGroup<RecordType>(_: ColumnGroupProps<RecordType>): null;
+
+export declare interface ColumnGroupProps<RecordType> extends Omit<ColumnGroupType<RecordType>, 'children'> {
+    children: ReactElement<ColumnProps<RecordType>> | Array<ReactElement<ColumnProps<RecordType>>>;
+}
+
+export declare interface ColumnGroupType<RecordType> extends ColumnSharedType<RecordType> {
+    colSpan?: number;
+    children: ColumnsType<RecordType>;
+}
+
+export declare interface ColumnProps<RecordType> extends ColumnType<RecordType> {
+    children?: null;
+}
+
+declare interface ColumnSharedType<RecordType> {
+    title?: ColumnTitle<RecordType>;
+    /** Hint badge rendered beside the column title. Accepts text, icons, or custom JSX. */
+    badge?: ReactNode;
+    key?: TableKey;
+    className?: string;
+    fixed?: FixedType;
+    width?: number | string;
+    align?: TableAlign;
+    ellipsis?: boolean | {
+        showTitle?: boolean;
+    };
+    responsive?: Breakpoint[];
+    onHeaderCell?: GetComponentProps<ColumnsType<RecordType>[number]>;
+}
+
+export declare type ColumnsType<RecordType = unknown> = readonly (ColumnGroupType<RecordType> | ColumnType<RecordType>)[];
+
+declare type ColumnTitle<RecordType> = ReactNode | ((props: ColumnTitleProps<RecordType>) => ReactNode);
+
+export declare interface ColumnTitleProps<RecordType> {
+    sortOrder?: SortOrder;
+    sortColumn?: ColumnType<RecordType>;
+    sortColumns?: Array<{
+        column: ColumnType<RecordType>;
+        order: SortOrder;
+    }>;
+    filters?: Record<string, FilterValue>;
+}
+
+export declare interface ColumnType<RecordType> extends ColumnSharedType<RecordType> {
+    colSpan?: number;
+    rowSpan?: number;
+    dataIndex?: TableDataIndex;
+    render?: (value: unknown, record: RecordType, index: number) => ReactNode | RenderedCell<RecordType>;
+    shouldCellUpdate?: (record: RecordType, previousRecord: RecordType) => boolean;
+    onCell?: GetComponentProps<RecordType>;
+    sorter?: boolean | CompareFn<RecordType> | {
+        compare?: CompareFn<RecordType>;
+        multiple?: number;
+    };
+    sortOrder?: SortOrder;
+    defaultSortOrder?: SortOrder;
+    sortDirections?: SortOrder[];
+    showSorterTooltip?: boolean | {
+        title?: ReactNode;
+    };
+    filtered?: boolean;
+    filters?: ColumnFilterItem[];
+    /** Props forwarded to BDropdown when rendering the built-in filter panel. Table-managed options, value, and callbacks take precedence. */
+    filterDropdownProps?: Partial<BDropdownProps>;
+    filterDropdown?: ReactNode | ((props: FilterDropdownProps) => ReactNode);
+    filterMultiple?: boolean;
+    filteredValue?: FilterValue | null;
+    defaultFilteredValue?: FilterValue | null;
+    filterIcon?: ReactNode | ((filtered: boolean) => ReactNode);
+    filterMode?: 'menu' | 'tree';
+    /** Show a search input. Pass a matcher to search custom option fields. */
+    filterSearch?: FilterSearchType;
+    /** Load filter options externally after the search input's 300ms debounce. */
+    filterRequest?: FilterRequest;
+    onFilter?: (value: TableKey | boolean, record: RecordType) => boolean;
+    filterDropdownOpen?: boolean;
+    onFilterDropdownOpenChange?: (open: boolean) => void;
+    filterResetToDefaultFilteredValue?: boolean;
+    /** @deprecated Use filterDropdownOpen. */
+    filterDropdownVisible?: boolean;
+    /** @deprecated Use onFilterDropdownOpenChange. */
+    onFilterDropdownVisibleChange?: (visible: boolean) => void;
+}
+
+export declare type CompareFn<RecordType> = (first: RecordType, second: RecordType, sortOrder?: SortOrder) => number;
+
 export declare function ConfirmTooltip({ placement, title, okText, cancelText, onOk, onCancel, className, style, }: ConfirmTooltipProps): JSX.Element;
 
 export declare interface ConfirmTooltipProps extends BaseTooltipProps {
@@ -352,11 +694,41 @@ export declare interface ConfirmTooltipProps extends BaseTooltipProps {
     onCancel?: () => void;
 }
 
-export declare function ContentTooltip({ placement, content, variant, className, style, }: ContentTooltipProps): JSX.Element;
-
-export declare interface ContentTooltipProps extends BaseTooltipProps {
-    content?: string;
+declare interface ContentTooltipProps extends BaseTooltipProps {
+    content?: ReactNode;
     variant?: TooltipVariant;
+    /** Tooltip background color, including the arrow. */
+    color?: string;
+    /** Tooltip content text color. */
+    fontColor?: string;
+}
+export { ContentTooltipProps as BTooltipProps }
+export { ContentTooltipProps }
+
+export declare interface ExpandableConfig<RecordType> {
+    expandedRowKeys?: readonly TableKey[];
+    defaultExpandedRowKeys?: readonly TableKey[];
+    expandedRowRender?: (record: RecordType, index: number, indent: number, expanded: boolean) => ReactNode;
+    columnTitle?: ReactNode;
+    expandRowByClick?: boolean;
+    expandIcon?: (props: {
+        prefixCls: string;
+        expanded: boolean;
+        record: RecordType;
+        expandable: boolean;
+        onExpand: (record: RecordType, event: React.MouseEvent<HTMLElement>) => void;
+    }) => ReactNode;
+    onExpand?: (expanded: boolean, record: RecordType) => void;
+    onExpandedRowsChange?: (expandedKeys: readonly TableKey[]) => void;
+    defaultExpandAllRows?: boolean;
+    indentSize?: number;
+    expandIconColumnIndex?: number;
+    showExpandColumn?: boolean;
+    expandedRowClassName?: RowClassName<RecordType>;
+    childrenColumnName?: string;
+    rowExpandable?: (record: RecordType) => boolean;
+    columnWidth?: number | string;
+    fixed?: FixedType;
 }
 
 export declare function FileCard(props: FileCardProps): JSX.Element;
@@ -382,10 +754,42 @@ export declare interface FileCardProps {
 
 export declare type FileType = 'pdf' | 'image' | 'doc' | 'docx' | 'xls' | 'xlsx' | 'ppt' | 'pptx' | 'zip' | 'rar' | 'txt' | 'other';
 
+export declare interface FilterDropdownProps {
+    prefixCls: string;
+    setSelectedKeys: (selectedKeys: TableKey[]) => void;
+    selectedKeys: TableKey[];
+    confirm: (options?: {
+        closeDropdown?: boolean;
+    }) => void;
+    clearFilters?: (options?: {
+        confirm?: boolean;
+        closeDropdown?: boolean;
+    }) => void;
+    filters?: ColumnFilterItem[];
+    close: () => void;
+    visible: boolean;
+}
+
+export declare type FilterRequest = (input: string) => ColumnFilterItem[] | Promise<ColumnFilterItem[]>;
+
+export declare type FilterSearchType<RecordType = ColumnFilterItem> = boolean | ((input: string, item: RecordType) => boolean);
+
+export declare type FilterValue = Array<TableKey | boolean>;
+
+export declare type FixedType = 'left' | 'right' | boolean;
+
+declare type GetComponentProps<DataType> = (data: DataType, index?: number) => HTMLAttributes<HTMLElement> | TdHTMLAttributes<HTMLTableCellElement>;
+
+export declare type GetRowKey<RecordType> = (record: RecordType, index?: number) => TableKey;
+
+declare const Group: ForwardRefExoticComponent<BCheckBoxGroupProps & RefAttributes<HTMLDivElement>>;
+
 export declare type ModalLang = 'zh' | 'en';
 
 export declare type ModalMode = 'standard' | 'bilingual' | 'single';
 
+export declare type OverlayScrollbarDirection = 'vertical' | 'horizontal' | 'both';
+
 export declare const Pagination: (props: PaginationProps) => JSX.Element | null;
 
 export declare type PaginationAlign = 'start' | 'center' | 'end';
@@ -451,6 +855,15 @@ export declare interface ProgressTooltipProps extends BaseTooltipProps {
     progress?: number;
 }
 
+export declare interface RenderedCell<RecordType> {
+    children?: ReactNode;
+    props?: CellType<RecordType>;
+}
+
+declare type RowClassName<RecordType> = (record: RecordType, index: number, indent: number) => string;
+
+declare type RowSelectMethod = 'all' | 'none' | 'invert' | 'single' | 'multiple';
+
 export declare function SkuInputCard({ id, name, onNameChange, mode, activeLang, onLangChange, showBody, error, onDelete, onPreviewImage, onDeleteImage, onUpload, onAssociate, images, labels, inputEvents, className, style, options, optionFilterProp, onSelect, onSearch, open: controlledOpen, onDropdownVisibleChange, }: SkuInputCardProps): JSX.Element;
 
 export declare interface SkuInputCardProps {
@@ -519,6 +932,174 @@ export declare interface SkuInputOption {
     disabled?: boolean;
 }
 
+export declare interface SorterResult<RecordType> {
+    column?: ColumnType<RecordType>;
+    order?: SortOrder;
+    field?: TableKey | readonly TableKey[];
+    columnKey?: TableKey;
+}
+
+export declare type SortOrder = 'ascend' | 'descend' | null;
+
+declare type TableAction = 'paginate' | 'sort' | 'filter';
+
+export declare type TableAlign = 'left' | 'center' | 'right';
+
+export declare interface TableComponents<RecordType> {
+    table?: React.ElementType;
+    header?: {
+        wrapper?: React.ElementType;
+        row?: React.ElementType;
+        cell?: React.ElementType;
+    };
+    body?: {
+        wrapper?: React.ElementType;
+        row?: React.ElementType;
+        cell?: React.ElementType;
+    } | ((data: readonly RecordType[], info: {
+        scrollbarSize: number;
+        ref: Ref<{
+            scrollLeft: number;
+        }>;
+        onScroll: (info: {
+            currentTarget?: HTMLElement;
+            scrollLeft?: number;
+        }) => void;
+    }) => ReactNode);
+}
+
+declare interface TableCurrentDataSource<RecordType> {
+    currentDataSource: RecordType[];
+    action: TableAction;
+}
+
+export declare type TableDataIndex = string | number | readonly (string | number)[];
+
+export declare type TableKey = Exclude<Key, bigint>;
+
+declare type TableLayout = 'auto' | 'fixed';
+
+export declare interface TableLocale {
+    filterTitle?: string;
+    filterConfirm?: ReactNode;
+    filterReset?: ReactNode;
+    filterEmptyText?: ReactNode;
+    filterCheckall?: ReactNode;
+    filterSearchPlaceholder?: string;
+    emptyText?: ReactNode | (() => ReactNode);
+    selectAll?: ReactNode;
+    selectNone?: ReactNode;
+    selectInvert?: ReactNode;
+    selectionAll?: ReactNode;
+    sortTitle?: string;
+    expand?: string;
+    collapse?: string;
+    triggerDesc?: string;
+    triggerAsc?: string;
+    cancelSort?: string;
+}
+
+export declare interface TablePaginationConfig extends PaginationProps {
+    position?: Array<'topLeft' | 'topCenter' | 'topRight' | 'bottomLeft' | 'bottomCenter' | 'bottomRight' | 'none'>;
+}
+
+export declare interface TableProps<RecordType extends object> {
+    columns?: ColumnsType<RecordType>;
+    children?: ReactNode;
+    dataSource?: readonly RecordType[];
+    rowKey?: keyof RecordType | string | GetRowKey<RecordType>;
+    rowSelection?: TableRowSelection<RecordType>;
+    pagination?: false | TablePaginationConfig;
+    loading?: boolean | {
+        spinning?: boolean;
+        tip?: ReactNode;
+        indicator?: ReactNode;
+    };
+    bordered?: boolean;
+    size?: TableSize;
+    showHeader?: boolean;
+    /** Empty-state description. Defaults to `t('暂无数据')`. */
+    emptyText?: ReactNode | (() => ReactNode);
+    /** Empty-state image URL or custom image node. */
+    emptyImage?: string | ReactNode;
+    /** Empty-state body height. Defaults to 454px. */
+    emptyHeight?: number | string;
+    /** Translation function used by built-in Table text. */
+    t?: (text: string) => string;
+    className?: string;
+    style?: CSSProperties;
+    id?: string;
+    rowClassName?: string | RowClassName<RecordType>;
+    tableLayout?: TableLayout;
+    scroll?: {
+        x?: number | true | string;
+        y?: number | string;
+        scrollToFirstRowOnChange?: boolean;
+    };
+    sticky?: boolean | {
+        offsetHeader?: number;
+        offsetSummary?: number;
+        offsetScroll?: number;
+        getContainer?: () => Window | HTMLElement;
+    };
+    direction?: 'ltr' | 'rtl';
+    title?: (data: readonly RecordType[]) => ReactNode;
+    footer?: (data: readonly RecordType[]) => ReactNode;
+    summary?: (data: readonly RecordType[]) => ReactNode;
+    components?: TableComponents<RecordType>;
+    onRow?: GetComponentProps<RecordType>;
+    onHeaderRow?: GetComponentProps<readonly ColumnType<RecordType>[]>;
+    expandable?: ExpandableConfig<RecordType>;
+    locale?: TableLocale;
+    sortDirections?: SortOrder[];
+    showSorterTooltip?: boolean | {
+        title?: ReactNode;
+    };
+    getPopupContainer?: (triggerNode: HTMLElement) => HTMLElement;
+    onChange?: (pagination: TablePaginationConfig, filters: Record<string, FilterValue | null>, sorter: SorterResult<RecordType> | SorterResult<RecordType>[], extra: TableCurrentDataSource<RecordType>) => void;
+    ref?: Ref<HTMLDivElement>;
+}
+
+export declare interface TableRowSelection<RecordType> {
+    preserveSelectedRowKeys?: boolean;
+    type?: TableSelectionType;
+    selectedRowKeys?: TableKey[];
+    defaultSelectedRowKeys?: TableKey[];
+    getCheckboxProps?: (record: RecordType) => {
+        disabled?: boolean;
+        name?: string;
+    };
+    columnTitle?: ReactNode;
+    columnWidth?: number | string;
+    fixed?: FixedType;
+    hideSelectAll?: boolean;
+    checkStrictly?: boolean;
+    selections?: boolean | Array<{
+        key: string;
+        text: ReactNode;
+        onSelect?: (keys: TableKey[]) => void;
+    }>;
+    renderCell?: (checked: boolean, record: RecordType, index: number, originNode: ReactNode) => ReactNode | RenderedCell<RecordType>;
+    onChange?: (selectedRowKeys: TableKey[], selectedRows: RecordType[], info?: {
+        type: RowSelectMethod;
+    }) => void;
+    onSelect?: (record: RecordType, selected: boolean, selectedRows: RecordType[], nativeEvent?: Event) => void;
+    onSelectAll?: (selected: boolean, selectedRows: RecordType[], changeRows?: RecordType[]) => void;
+    onSelectInvert?: (selectedRowKeys: TableKey[]) => void;
+    onSelectNone?: () => void;
+    onSelectMultiple?: (selected: boolean, selectedRows: RecordType[], changeRows: RecordType[]) => void;
+}
+
+export declare type TableSelectionType = 'checkbox' | 'radio';
+
+export declare type TableSize = 'large' | 'middle' | 'small';
+
+export declare function TabPane(_: BTabsTabPaneProps): ReactElement | null;
+
+export declare namespace TabPane {
+    var displayName: string;
+}
+
 export declare type TooltipPlacement = 'auto' | 'top' | 'topLeft' | 'topRight' | 'bottom' | 'bottomLeft' | 'bottomRight' | 'left' | 'leftTop' | 'leftBottom' | 'right' | 'rightTop' | 'rightBottom';
 
 export declare type TooltipVariant = 'default' | 'light' | 'bordered' | 'tinted';