@unicom-cloud/ui 0.8.41

package/types/table/interface.d.ts

@@ -0,0 +1,295 @@
+import React, { CSSProperties, ReactNode } from 'react';
+import { PaginationProps } from '../pagination/Pagination';
+import { SpinProps } from '../spin';
+import type { TooltipProps } from '../tooltip';
+import { TriggerProps } from '../trigger';
+import { AvailableVirtualListProps, VirtualListHandle } from '../virtual-list';
+export type RowCallbackProps = {
+    onClick?: (event: any) => void;
+    onDoubleClick?: (event: any) => void;
+    onContextMenu?: (event: any) => void;
+    onMouseEnter?: (event: any) => void;
+    onMouseLeave?: (event: any) => void;
+    onHandleSave?: (row: any) => void;
+    [name: string]: any;
+};
+export type SorterFn = (a: any, b: any) => number;
+export interface TableProps<T = any> {
+    style?: CSSProperties;
+    className?: string | string[];
+    tableLayoutFixed?: boolean;
+    rowKey?: React.Key | ((record: T) => React.Key);
+    columns?: ColumnProps<T>[];
+    component?: ComponentProps;
+    data?: T[];
+    border?: boolean | {
+        wrapper?: boolean;
+        headerCell?: boolean;
+        bodyCell?: boolean;
+        cell?: boolean;
+    };
+    borderCell?: boolean;
+    hover?: boolean;
+    defaultExpandAllRows?: boolean;
+    expandedRowKeys?: (string | number)[];
+    defaultExpandedRowKeys?: (string | number)[];
+    expandedRowRender?: (record: T, index: number) => ReactNode;
+    expandProps?: ExpandProps<T>;
+    onExpand?: (record: T, expanded: boolean) => void;
+    onExpandedRowsChange?: (expandedRows: (string | number)[]) => void;
+    loading?: boolean | SpinProps;
+    noDataElement?: string | ReactNode;
+    showHeader?: boolean;
+    showSorterTooltip?: boolean | TooltipProps;
+    stripe?: boolean;
+    size?: 'default' | 'middle' | 'small' | 'mini';
+    onChange?: (pagination: PaginationProps, sorter: SorterInfo | SorterInfo[], filters: Partial<Record<keyof T, string[]>>, extra: {
+        currentData: T[];
+        currentAllData: T[];
+        action: 'paginate' | 'sort' | 'filter';
+    }) => void;
+    pagination?: PaginationProps | boolean;
+    renderPagination?: (paginationNode?: ReactNode) => ReactNode;
+    scroll?: {
+        x?: number | string | boolean;
+        y?: number | string | boolean;
+    };
+    rowClassName?: (record: T, index: number) => string;
+    rowSelection?: RowSelectionProps<T>;
+    onHeaderRow?: (columns: ColumnProps<T>[], index: number) => RowCallbackProps;
+    onRow?: (record: T, index: number) => RowCallbackProps;
+    prefixCls?: string;
+    placeholder?: ReactNode;
+    pagePosition?: 'br' | 'bl' | 'tr' | 'tl' | 'topCenter' | 'bottomCenter';
+    childrenColumnName?: string;
+    indentSize?: number;
+    footer?: (currentPageDate: any) => ReactNode;
+    virtualized?: boolean;
+    virtualListProps?: AvailableVirtualListProps;
+    summary?: (currentData?: T[]) => ReactNode;
+}
+export interface RowSelectionProps<T = any> {
+    checkAll?: boolean;
+    checkStrictly?: boolean;
+    checkCrossPage?: boolean;
+    columnTitle?: string | ReactNode;
+    columnWidth?: number;
+    checkboxProps?: (record: T) => {
+        [key: string]: any;
+    };
+    fixed?: boolean;
+    onChange?: (selectedRowKeys: (string | number)[], selectedRows: T[]) => void;
+    onSelect?: (selected: boolean, record: T, selectedRows: T[]) => void;
+    onSelectAll?: (selected: boolean, selectedRows: any) => void;
+    preserveSelectedRowKeys?: boolean;
+    renderCell?: (originNode: any, checked: boolean, record: T) => ReactNode;
+    selectedRowKeys?: (string | number)[];
+    type?: 'checkbox' | 'radio';
+    pureKeys?: boolean;
+}
+export interface ExpandProps<T = any> {
+    icon?: (props: {
+        expanded: boolean;
+        record: Record<string, any>;
+    }) => ReactNode;
+    width?: number;
+    columnTitle?: ReactNode;
+    rowExpandable?: (record: T) => boolean;
+    expandRowByClick?: boolean;
+    strictTreeData?: boolean;
+}
+export interface ColumnProps<T = any> {
+    className?: string | string[];
+    align?: 'left' | 'center' | 'right';
+    ellipsis?: boolean;
+    headerCellStyle?: CSSProperties;
+    bodyCellStyle?: CSSProperties;
+    cellStyle?: CSSProperties;
+    title: React.ReactNode;
+    width?: number | string;
+    dataIndex?: string;
+    key?: string | number;
+    render?: (col: any, item: T, index: number) => any;
+    placeholder?: ReactNode;
+    sorter?: SorterFn | boolean | {
+        compare?: SorterFn;
+        multiple?: number;
+    };
+    filters?: {
+        text?: ReactNode;
+        value?: any;
+        [key: string]: any;
+    }[];
+    defaultFilters?: string[];
+    defaultSortOrder?: 'ascend' | 'descend';
+    filteredValue?: string[];
+    sortOrder?: 'ascend' | 'descend';
+    sortDirections?: Array<'ascend' | 'descend'>;
+    filterMultiple?: boolean;
+    filterIcon?: ReactNode;
+    filterDropdown?: (props: {
+        filterKeys?: string[];
+        setFilterKeys?: (filterKeys: string[], callback?: Function) => void;
+        confirm?: Function;
+    }) => ReactNode;
+    filterDropdownProps?: {
+        triggerProps?: TriggerProps;
+    };
+    onFilterDropdownVisibleChange?: (visible: boolean) => void;
+    onFilter?: (value: any, row: any) => any;
+    fixed?: 'left' | 'right';
+    onHeaderCell?: (column: any, index: any) => RowCallbackProps;
+    onCell?: (record: any, index: any, column: any) => RowCallbackProps;
+    children?: ColumnProps<T>[];
+    rowSpan?: number;
+    colSpan?: number;
+    headerCellProps?: RowCallbackProps;
+    editable?: boolean;
+    prefixCls?: string;
+    currentFilters?: {
+        [key: string]: any;
+    };
+    component?: ComponentProps;
+    columnFixedStyle?: CSSProperties;
+    column?: any;
+    [key: string]: any;
+}
+export type InternalColumnProps<T = any> = ColumnProps<T> & {
+    $$isOperation?: boolean;
+    $$isFirstColumn?: boolean;
+    $$columnIndex?: number | number[];
+    node?: ReactNode;
+};
+export interface ColumnComponentProps<T = any> extends ColumnProps<T> {
+    onSort: (direction: string | undefined, field: string | number) => void;
+    onHandleFilter: (column: Record<string, any>, filter: Record<string, any>) => void;
+    onHandleFilterReset: (column: {
+        [key: string]: any;
+    }) => void;
+    currentSorter?: SorterInfo;
+    currentFilter?: {
+        [key: string]: any;
+    };
+    _key?: string | number;
+    showSorterTooltip?: boolean | TooltipProps;
+    index?: number;
+}
+export type ComponentProps = {
+    table?: any;
+    header?: {
+        operations?: (nodes: {
+            selectionNode?: ReactNode;
+            expandNode?: ReactNode;
+        }) => {
+            name?: string;
+            node?: ReactNode;
+            width?: number;
+        }[];
+        wrapper?: any;
+        thead?: any;
+        row?: any;
+        th?: any;
+        cell?: any;
+    };
+    body?: {
+        operations?: (nodes: {
+            selectionNode?: ReactNode;
+            expandNode?: ReactNode;
+        }) => {
+            name?: string;
+            node?: ReactNode | ((record: any) => ReactNode);
+            width?: number;
+        }[];
+        wrapper?: any;
+        tbody?: any;
+        row?: any;
+        td?: any;
+        cell?: any;
+    };
+};
+export interface TheadProps<T = any> {
+    expandedRowRender?: (record: {
+        [key: string]: any;
+    }, index: number) => ReactNode;
+    onCheckAll: (_: any, e: any) => void;
+    onSort: (direction: any, field: any) => void;
+    data: T[];
+    onHandleFilter: (column: any, filter: any) => void;
+    onHandleFilterReset: (filter: any) => void;
+    currentSorter: SorterInfo;
+    activeSorters: SorterInfo[];
+    selectedRowKeys: (string | number)[];
+    onHeaderRow?: (columns: any, index: number) => RowCallbackProps;
+    prefixCls?: string;
+    rowSelection?: RowSelectionProps;
+    columnTitle?: string | ReactNode;
+    currentFilters?: Partial<Record<keyof T, string[]>>;
+    rowKey?: TableProps['rowKey'];
+    component?: ComponentProps;
+    expandProps?: ExpandProps<T>;
+    allSelectedRowKeys?: (string | number)[];
+    groupColumns?: InternalColumnProps<T>[][];
+    stickyOffsets?: number[];
+    groupStickyClassNames?: string[][];
+    showSorterTooltip?: boolean | TooltipProps;
+}
+export type GetRowKeyType<T> = (record: T) => string;
+export interface TbodyProps<T = any> {
+    data: T[];
+    selectedRowKeys: React.Key[];
+    indeterminateKeys: React.Key[];
+    component?: ComponentProps;
+    expandedRowKeys: React.Key[];
+    columns: InternalColumnProps<T>[];
+    noDataElement?: string | ReactNode;
+    onCheck: (checked: boolean, record: any) => void;
+    onCheckRadio: (key: any, record: any) => void;
+    onClickExpandBtn: (key: React.Key) => void;
+    pagination?: PaginationProps | boolean;
+    scroll?: {
+        x?: number | string | boolean;
+        y?: number | string | boolean;
+    };
+    expandedRowRender?: (record: T, index: number) => ReactNode;
+    rowClassName?: (record: T, index: number) => string;
+    onRow?: (record: T, index: number) => RowCallbackProps;
+    prefixCls?: string;
+    rowSelection?: RowSelectionProps<T>;
+    expandProps?: ExpandProps<T>;
+    childrenColumnName?: string;
+    indentSize?: number;
+    hasFixedColumn?: boolean;
+    tableViewWidth?: number;
+    currentSorter?: SorterInfo;
+    activeSorters?: SorterInfo[];
+    virtualized?: boolean;
+    virtualListProps?: AvailableVirtualListProps;
+    stickyOffsets?: number[];
+    stickyClassNames?: string[];
+    getRowKey?: GetRowKeyType<T>;
+    placeholder?: ReactNode;
+    saveVirtualListRef?: (ref: VirtualListHandle) => void;
+}
+export interface TfootProps<T = any> {
+    prefixCls?: string;
+    summary?: (currentData?: T[]) => ReactNode;
+    data?: T[];
+    columns?: InternalColumnProps<T>[];
+    stickyOffsets?: number[];
+    stickyClassNames?: string[];
+}
+export declare type SortDirection = 'descend' | 'ascend';
+export interface SorterResult {
+    direction?: SortDirection;
+    field?: string;
+}
+export interface SorterInfo {
+    direction?: SortDirection;
+    field?: string | number;
+    sorterFn?: SorterFn;
+    priority?: number;
+}
+export interface SummaryProps {
+    fixed?: 'top' | 'bottom';
+    children?: ReactNode;
+}

package/types/table/style/index.d.ts

@@ -0,0 +1,11 @@
+import '../../button/style';
+import '../../checkbox/style';
+import '../../empty/style';
+import '../../pagination/style';
+import '../../radio/style';
+import '../../space/style';
+import '../../spin/style';
+import '../../style/index.less';
+import '../../tooltip/style';
+import '../../trigger/style';
+import './index.less';

package/types/table/summary/Cell.d.ts

@@ -0,0 +1,12 @@
+import { HTMLAttributes, ReactNode } from 'react';
+import { Omit } from '../../utils/type';
+interface SummaryCellProps extends Omit<HTMLAttributes<HTMLElement>, 'children'> {
+    children?: ReactNode;
+    colSpan?: number;
+    rowSpan?: number;
+}
+declare function Cell(props: SummaryCellProps): import("react/jsx-dev-runtime").JSX.Element;
+declare namespace Cell {
+    var __PQB_TABLE_SUMMARY_CELL__: boolean;
+}
+export default Cell;

package/types/table/summary/Row.d.ts

@@ -0,0 +1,7 @@
+import { HTMLAttributes, ReactNode } from 'react';
+import { Omit } from '../../utils/type';
+interface SummaryRowProps extends Omit<HTMLAttributes<HTMLTableRowElement>, 'children'> {
+    children?: ReactNode;
+}
+declare function Row(props: SummaryRowProps): import("react/jsx-dev-runtime").JSX.Element;
+export default Row;

package/types/table/summary/context.d.ts

@@ -0,0 +1,9 @@
+import { ColumnProps } from '../../table/interface';
+interface SummaryContextProps {
+    columns?: ColumnProps[];
+    stickyOffsets?: number[];
+    stickyClassNames?: string[];
+    prefixCls?: string;
+}
+export declare const SummaryContext: import("react").Context<SummaryContextProps>;
+export {};

package/types/table/summary/index.d.ts

@@ -0,0 +1,8 @@
+import { ReactElement } from 'react';
+import { SummaryProps } from '../../table/interface';
+declare function Summary(props: SummaryProps): ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+declare namespace Summary {
+    var Row: typeof import("./Row").default;
+    var Cell: typeof import("./Cell").default;
+}
+export default Summary;

package/types/table/tbody/Td.d.ts

@@ -0,0 +1,25 @@
+import React, { ReactNode } from 'react';
+import { ComponentProps, InternalColumnProps, SorterInfo } from '../../table/interface';
+type TdType = {
+    prefixCls?: string;
+    virtualized?: boolean;
+    stickyClassName?: string;
+    stickyOffset?: number;
+    component?: ComponentProps;
+    InnerComponentTd?: any;
+    column?: InternalColumnProps;
+    columnIndex?: number;
+    currentSorter?: SorterInfo;
+    placeholder?: ReactNode;
+    indentSize?: number;
+    record?: any;
+    trIndex?: number;
+    level?: number;
+    haveTreeData?: boolean;
+    recordHaveChildren?: boolean;
+    rowKey?: string;
+    renderExpandIcon?: (record: any, rowKey: string) => ReactNode;
+};
+declare function Td(props: TdType): import("react/jsx-dev-runtime").JSX.Element | null;
+declare const _default: React.MemoExoticComponent<typeof Td>;
+export default _default;

package/types/table/tbody/Tr.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import { TbodyProps } from '../../table/interface';
+type TrType<T = any> = TbodyProps<T> & {
+    record?: T;
+    shouldRowExpand?: (record: any, index: any) => boolean;
+    index?: number;
+    type?: string;
+    level?: number;
+};
+interface ForwardRefTrType extends React.ForwardRefExoticComponent<React.PropsWithoutRef<TrType> & React.RefAttributes<unknown>> {
+    <T = any>(props: React.PropsWithChildren<TrType<T>> & {
+        ref?: React.Ref<unknown>;
+    }): React.ReactElement;
+}
+declare const _default: ForwardRefTrType;
+export default _default;

package/types/table/tbody/index.d.ts

@@ -0,0 +1,3 @@
+import { TbodyProps } from '../../table/interface';
+declare function TBody<T>(props: TbodyProps<T>): import("react/jsx-dev-runtime").JSX.Element;
+export default TBody;

package/types/table/tfoot/index.d.ts

@@ -0,0 +1,3 @@
+import { TfootProps } from '../../table/interface';
+declare function Tfoot<T>(props: TfootProps<T>): import("react/jsx-dev-runtime").JSX.Element;
+export default Tfoot;

package/types/table/thead/Column.d.ts

@@ -0,0 +1,3 @@
+import { ColumnComponentProps } from '../../table/interface';
+declare function Column<T>({ onSort, onFilter, onHandleFilter, onHandleFilterReset, currentFilters, currentSorter, _key, dataIndex, title, sorter, sortDirections, filters, columnFixedStyle, className, cellStyle, headerCellStyle, rowSpan, colSpan, headerCellProps, prefixCls, align, component, filterIcon, filterDropdown, filterMultiple, ellipsis, filterDropdownProps, onFilterDropdownVisibleChange, column, showSorterTooltip, index, }: ColumnComponentProps<T>): false | import("react/jsx-dev-runtime").JSX.Element;
+export default Column;

package/types/table/thead/index.d.ts

@@ -0,0 +1,3 @@
+import { TheadProps } from '../../table/interface';
+declare function THead<T>(props: TheadProps<T>): import("react/jsx-dev-runtime").JSX.Element;
+export default THead;

package/types/table/util.d.ts

@@ -0,0 +1,17 @@
+import type { ColumnProps, SorterFn } from './interface';
+export declare function px2Number(width: number | string): number | string;
+export declare function getScrollBarHeight(ele: HTMLElement | null): number;
+export declare function getScrollBarWidth(ele: HTMLElement | null): number;
+export declare function isChildrenNotEmpty(record: any, field: string): any;
+export declare function deepCloneData(data: any, childrenColumnName: any): never[];
+export declare function getOriginData(data: any): any;
+export declare function getSelectedKeys(record: any, checked: any, checkedRowKeys: never[] | undefined, _indeterminateKeys: never[] | undefined, getRowKey: any, childrenColumnName: any, checkConnected: any): {
+    selectedRowKeys: never[];
+    indeterminateKeys: never[];
+};
+export declare function getSelectedKeysByData(flattenData: any, checkedKeys: never[] | undefined, getRowKey: any, childrenColumnName: string, checkConnected: boolean): {
+    selectedRowKeys: never[];
+    indeterminateKeys: never[];
+};
+export declare function getSorterFn(sorter: ColumnProps['sorter']): SorterFn | null;
+export declare function getSorterPriority(sorter: ColumnProps['sorter']): number | undefined;

package/types/tabs/Tab.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import TabPane, { TabPaneProps, TabPaneType } from './TabPane';
+import type { TabsProps } from './interface';
+export declare const TabsContext: React.Context<TabsProps & {
+    getIdPrefix?: ((suffix?: number | string) => {
+        tab: string;
+        tabpane: string;
+    }) | undefined;
+    paneChildren?: React.ReactElement<TabPaneProps, TabPaneType>[] | undefined;
+    prefixCls?: string | undefined;
+}>;
+declare const TabsComponent: React.ForwardRefExoticComponent<TabsProps & {
+    children?: React.ReactNode;
+} & React.RefAttributes<unknown>> & {
+    TabPane: typeof TabPane;
+};
+export default TabsComponent;
+export type { TabsProps };

package/types/tabs/TabContent.d.ts

@@ -0,0 +1,9 @@
+import { ReactElement } from 'react';
+import { TabsProps } from './Tab';
+import { TabPaneProps, TabPaneType } from './TabPane';
+interface TabContentProps extends Pick<TabsProps, 'animation' | 'activeTab' | 'direction' | 'lazyload' | 'destroyOnHide'> {
+    prefixCls: string | undefined;
+    paneChildren: ReactElement<TabPaneProps, TabPaneType>[];
+}
+export default function TabContent(props: TabContentProps): import("react/jsx-dev-runtime").JSX.Element | null;
+export {};

package/types/tabs/TabPane.d.ts

@@ -0,0 +1,8 @@
+import { ForwardRefExoticComponent, PropsWithChildren } from 'react';
+import type { TabPaneProps } from './interface';
+export type TabPaneType = ForwardRefExoticComponent<PropsWithChildren<TabPaneProps>> & {
+    isTabPane: boolean;
+};
+declare const TabPaneRef: TabPaneType;
+export default TabPaneRef;
+export type { TabPaneProps };

package/types/tabs/hook/useDomSize.d.ts

@@ -0,0 +1,11 @@
+import React, { MutableRefObject } from 'react';
+export type ReturnType = {
+    height: number;
+    width: number;
+    domRect?: DOMRect;
+};
+export default function DomSize<T extends HTMLElement>(): [
+    MutableRefObject<T>,
+    ReturnType,
+    React.Dispatch<React.SetStateAction<ReturnType>>
+];

package/types/tabs/hook/useHeaderScroll.d.ts

@@ -0,0 +1,9 @@
+import { MutableRefObject } from 'react';
+export default function useHeaderScroll<T extends HTMLElement>(props: {
+    headerWrapperRef: MutableRefObject<T | undefined>;
+    headerOffset: number;
+    align: 'left' | 'right';
+    direction: 'horizontal' | 'vertical' | undefined;
+    isScrollable: boolean;
+    onScroll: (offset: number) => void | boolean;
+}): void;

package/types/tabs/index.d.ts

@@ -0,0 +1,4 @@
+import './style';
+import Tabs from './Tab';
+export default Tabs;
+export type { TabPaneProps, TabsProps } from './interface';

package/types/tabs/interface.d.ts

@@ -0,0 +1,66 @@
+import { CSSProperties, ReactElement, ReactNode } from 'react';
+import TabHeader from './tab-header';
+export interface TabsProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    children?: ReactNode;
+    defaultActiveTab?: string;
+    activeTab?: string;
+    animation?: boolean | {
+        tabPane?: boolean;
+        inkBar?: boolean;
+    };
+    tabPosition?: 'left' | 'right' | 'top' | 'bottom';
+    direction?: 'horizontal' | 'vertical';
+    size?: 'mini' | 'small' | 'default' | 'large';
+    type?: 'line' | 'card' | 'card-gutter' | 'text' | 'rounded' | 'capsule';
+    inkBarSize?: {
+        width?: CSSProperties['width'];
+        height?: CSSProperties['height'];
+    };
+    headerPadding?: boolean;
+    overflow?: 'scroll' | 'dropdown';
+    editable?: boolean;
+    showAddButton?: boolean;
+    icons?: {
+        add?: ReactNode;
+        delete?: ReactNode;
+        prev?: ReactNode;
+        next?: ReactNode;
+        dropdown?: ReactNode;
+    };
+    scrollAfterEdit?: {
+        delete?: boolean;
+        add?: boolean;
+    };
+    extra?: ReactNode;
+    destroyOnHide?: boolean;
+    lazyload?: boolean;
+    justify?: boolean;
+    deleteButton?: ReactNode;
+    addButton?: ReactNode;
+    scrollPosition?: 'start' | 'end' | 'center' | 'auto' | number;
+    onChange?: (key: string) => void;
+    onClickTab?: (key: string) => void;
+    onAddTab?: () => void;
+    onDeleteTab?: (key: string) => void;
+    renderTabHeader?: (tabProps: TabsProps, DefaultTabHeader: typeof TabHeader) => ReactElement;
+    headerSticky?: object;
+    renderTabTitle?: (tabTitle: ReactNode, info: {
+        key: string | number;
+        isActive: boolean;
+        disabled: boolean;
+        editable: boolean;
+    }) => ReactNode;
+}
+export interface TabPaneProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    title: string | ReactNode;
+    destroyOnHide?: boolean;
+    disabled?: boolean;
+    closable?: boolean;
+    isActive?: boolean;
+    lazyload?: boolean;
+    children?: ReactNode;
+}

package/types/tabs/style/index.d.ts

@@ -0,0 +1,3 @@
+import '../../menu/style';
+import '../../style/index.less';
+import './index.less';

package/types/tabs/tab-header/DropdownIcon.d.ts

@@ -0,0 +1 @@
+export default function DropdownIcon(props: any): import("react/jsx-dev-runtime").JSX.Element | null;

package/types/tabs/tab-header/TabInk.d.ts

@@ -0,0 +1,11 @@
+declare const TabInk: ({ prefixCls, animation, disabled, direction, getTitleRef, activeTab, getHeaderRef, inkBarSize, }: {
+    prefixCls: any;
+    animation: any;
+    disabled: any;
+    direction: any;
+    getTitleRef: any;
+    activeTab: any;
+    getHeaderRef: any;
+    inkBarSize: any;
+}) => import("react/jsx-dev-runtime").JSX.Element;
+export default TabInk;

package/types/tabs/tab-header/TabNavIcon.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import type { TabsProps } from '../../tabs/interface';
+import { ReturnType } from '../hook/useDomSize';
+interface TabNavIconProps {
+    direction: TabsProps['direction'];
+    align: 'left' | 'right';
+    headerSize: ReturnType;
+    headerWrapperSize: ReturnType;
+    currentOffset: number;
+    prefixCls?: string;
+    icon?: React.ReactNode;
+    iconPos?: 'prev' | 'next';
+    rtl?: boolean;
+    onChange?: (offset: number) => void;
+}
+declare const TabNavIcon: (props: TabNavIconProps) => import("react/jsx-dev-runtime").JSX.Element | null;
+export default TabNavIcon;

package/types/tabs/tab-header/TabTitle.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+declare const _default: React.ForwardRefExoticComponent<{
+    prefixCls: any;
+    onDeleteTab: any;
+    tabKey: any;
+    isActive: any;
+    onClickTab: any;
+    disabled?: boolean | undefined;
+    title: any;
+    editable: any;
+    renderTitle: any;
+    deleteIcon: any;
+    deleteButton: any;
+    getIdPrefix: any;
+    index: any;
+} & React.RefAttributes<unknown>>;
+export default _default;

package/types/tabs/tab-header/index.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import type { TabsProps } from '../../tabs/interface';
+declare const TabHeader: React.ForwardRefExoticComponent<TabsProps & React.RefAttributes<HTMLDivElement>>;
+export default TabHeader;

package/types/tabs/util.d.ts

@@ -0,0 +1,12 @@
+export declare const getRectDiff: (node: HTMLElement, parentNode: HTMLElement) => {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+};
+export declare const updateScrollOffset: (parentNode: HTMLElement, direction: 'horizontal' | 'vertical') => void;
+export declare const getKeyDownEvent: ({ onPressEnter }: {
+    onPressEnter: any;
+}) => {
+    onKeyDown: (e: any) => void;
+};

package/types/tag/index.d.ts

@@ -0,0 +1,5 @@
+import './style';
+import type { TagProps } from './interface';
+declare const TagComponent: import("react").ForwardRefExoticComponent<TagProps & import("react").RefAttributes<unknown>>;
+export default TagComponent;
+export type { TagProps };