acud 0.0.60

package/es/table/baseTable/Body/MeasureCell.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+export interface MeasureCellProps {
+    columnKey: React.Key;
+    onColumnResize: (key: React.Key, width: number) => void;
+}
+export default function MeasureCell({ columnKey, onColumnResize }: MeasureCellProps): JSX.Element;

package/es/table/baseTable/Body/MeasureCell.js

@@ -0,0 +1,27 @@
+import * as React from 'react';
+import ResizeObserver from 'rc-resize-observer';
+export default function MeasureCell(_ref) {
+  var columnKey = _ref.columnKey,
+      onColumnResize = _ref.onColumnResize;
+  var cellRef = React.useRef();
+  React.useEffect(function () {
+    if (cellRef.current) {
+      onColumnResize(columnKey, cellRef.current.offsetWidth);
+    }
+  }, []);
+  return /*#__PURE__*/React.createElement(ResizeObserver, {
+    data: columnKey
+  }, /*#__PURE__*/React.createElement("td", {
+    ref: cellRef,
+    style: {
+      padding: 0,
+      border: 0,
+      height: 0
+    }
+  }, /*#__PURE__*/React.createElement("div", {
+    style: {
+      height: 0,
+      overflow: 'hidden'
+    }
+  }, "\xA0")));
+}

package/es/table/baseTable/Body/MeasureRow.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+export interface MeasureCellProps {
+    prefixCls: string;
+    onColumnResize: (key: React.Key, width: number) => void;
+    columnsKey: React.Key[];
+}
+export default function MeasureRow({ prefixCls, columnsKey, onColumnResize }: MeasureCellProps): JSX.Element;

package/es/table/baseTable/Body/MeasureRow.js

@@ -0,0 +1,53 @@
+import * as React from 'react';
+import ResizeObserver from 'rc-resize-observer';
+import MeasureCell from './MeasureCell';
+import raf from "rc-util/es/raf";
+export default function MeasureRow(_ref) {
+  var prefixCls = _ref.prefixCls,
+      columnsKey = _ref.columnsKey,
+      onColumnResize = _ref.onColumnResize;
+  // delay state update while resize continuously, e.g. window resize
+  var resizedColumnsRef = React.useRef(new Map());
+  var rafIdRef = React.useRef(null);
+
+  var delayOnColumnResize = function delayOnColumnResize() {
+    if (rafIdRef.current === null) {
+      rafIdRef.current = raf(function () {
+        resizedColumnsRef.current.forEach(function (width, columnKey) {
+          onColumnResize(columnKey, width);
+        });
+        resizedColumnsRef.current.clear();
+        rafIdRef.current = null;
+      }, 2);
+    }
+  };
+
+  React.useEffect(function () {
+    return function () {
+      raf.cancel(rafIdRef.current);
+    };
+  }, []);
+  return /*#__PURE__*/React.createElement("tr", {
+    "aria-hidden": "true",
+    className: "".concat(prefixCls, "-measure-row"),
+    style: {
+      height: 0,
+      fontSize: 0
+    }
+  }, /*#__PURE__*/React.createElement(ResizeObserver.Collection, {
+    onBatchResize: function onBatchResize(infoList) {
+      infoList.forEach(function (_ref2) {
+        var columnKey = _ref2.data,
+            size = _ref2.size;
+        resizedColumnsRef.current.set(columnKey, size.offsetWidth);
+      });
+      delayOnColumnResize();
+    }
+  }, columnsKey.map(function (columnKey) {
+    return /*#__PURE__*/React.createElement(MeasureCell, {
+      key: columnKey,
+      columnKey: columnKey,
+      onColumnResize: onColumnResize
+    });
+  })));
+}

package/es/table/baseTable/Body/index.d.ts

@@ -0,0 +1,15 @@
+import * as React from 'react';
+import type { GetRowKey, Key, GetComponentProps } from '../interface';
+export interface BodyProps<RecordType> {
+    data: readonly RecordType[];
+    getRowKey: GetRowKey<RecordType>;
+    measureColumnWidth: boolean;
+    expandedKeys: Set<Key>;
+    onRow: GetComponentProps<RecordType>;
+    rowExpandable: (record: RecordType) => boolean;
+    emptyNode: React.ReactNode;
+    childrenColumnName: string;
+}
+declare function Body<RecordType>({ data, getRowKey, measureColumnWidth, expandedKeys, onRow, rowExpandable, emptyNode, childrenColumnName }: BodyProps<RecordType>): JSX.Element;
+declare const MemoBody: React.MemoExoticComponent<typeof Body>;
+export default MemoBody;

package/es/table/baseTable/Body/index.js

@@ -0,0 +1,114 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import * as React from 'react';
+import TableContext from '../context/TableContext';
+import ExpandedRow from './ExpandedRow';
+import BodyContext from '../context/BodyContext';
+import { getColumnsKey } from '../utils/valueUtil';
+import ResizeContext from '../context/ResizeContext';
+import BodyRow from './BodyRow';
+import useFlattenRecords from '../hooks/useFlattenRecords';
+import HoverContext from '../context/HoverContext';
+import MeasureRow from './MeasureRow';
+
+function Body(_ref) {
+  var data = _ref.data,
+      getRowKey = _ref.getRowKey,
+      measureColumnWidth = _ref.measureColumnWidth,
+      expandedKeys = _ref.expandedKeys,
+      onRow = _ref.onRow,
+      rowExpandable = _ref.rowExpandable,
+      emptyNode = _ref.emptyNode,
+      childrenColumnName = _ref.childrenColumnName;
+
+  var _React$useContext = React.useContext(ResizeContext),
+      onColumnResize = _React$useContext.onColumnResize;
+
+  var _React$useContext2 = React.useContext(TableContext),
+      prefixCls = _React$useContext2.prefixCls,
+      getComponent = _React$useContext2.getComponent;
+
+  var _React$useContext3 = React.useContext(BodyContext),
+      flattenColumns = _React$useContext3.flattenColumns;
+
+  var flattenData = useFlattenRecords(data, childrenColumnName, expandedKeys, getRowKey); // ====================== Hover =======================
+
+  var _React$useState = React.useState(-1),
+      _React$useState2 = _slicedToArray(_React$useState, 2),
+      startRow = _React$useState2[0],
+      setStartRow = _React$useState2[1];
+
+  var _React$useState3 = React.useState(-1),
+      _React$useState4 = _slicedToArray(_React$useState3, 2),
+      endRow = _React$useState4[0],
+      setEndRow = _React$useState4[1];
+
+  var onHover = React.useCallback(function (start, end) {
+    setStartRow(start);
+    setEndRow(end);
+  }, []);
+  var hoverContext = React.useMemo(function () {
+    return {
+      startRow: startRow,
+      endRow: endRow,
+      onHover: onHover
+    };
+  }, [onHover, startRow, endRow]); // ====================== Render ======================
+
+  var bodyNode = React.useMemo(function () {
+    var WrapperComponent = getComponent(['body', 'wrapper'], 'tbody');
+    var trComponent = getComponent(['body', 'row'], 'tr');
+    var tdComponent = getComponent(['body', 'cell'], 'td');
+    var rows;
+
+    if (data.length) {
+      rows = flattenData.map(function (item, idx) {
+        var record = item.record,
+            indent = item.indent,
+            renderIndex = item.index;
+        var key = getRowKey(record, idx);
+        return /*#__PURE__*/React.createElement(BodyRow, {
+          key: key,
+          rowKey: key,
+          record: record,
+          recordKey: key,
+          index: idx,
+          renderIndex: renderIndex,
+          rowComponent: trComponent,
+          cellComponent: tdComponent,
+          expandedKeys: expandedKeys,
+          onRow: onRow,
+          getRowKey: getRowKey,
+          rowExpandable: rowExpandable,
+          childrenColumnName: childrenColumnName,
+          indent: indent
+        });
+      });
+    } else {
+      rows = /*#__PURE__*/React.createElement(ExpandedRow, {
+        expanded: true,
+        className: "".concat(prefixCls, "-placeholder"),
+        prefixCls: prefixCls,
+        component: trComponent,
+        cellComponent: tdComponent,
+        colSpan: flattenColumns.length,
+        isEmpty: true
+      }, emptyNode);
+    }
+
+    var columnsKey = getColumnsKey(flattenColumns);
+    return /*#__PURE__*/React.createElement(WrapperComponent, {
+      className: "".concat(prefixCls, "-tbody")
+    }, measureColumnWidth && /*#__PURE__*/React.createElement(MeasureRow, {
+      prefixCls: prefixCls,
+      columnsKey: columnsKey,
+      onColumnResize: onColumnResize
+    }), rows);
+  }, [data, prefixCls, onRow, measureColumnWidth, expandedKeys, getRowKey, getComponent, emptyNode, flattenColumns, childrenColumnName, onColumnResize, rowExpandable, flattenData]);
+  return /*#__PURE__*/React.createElement(HoverContext.Provider, {
+    value: hoverContext
+  }, bodyNode);
+}
+
+var MemoBody = /*#__PURE__*/React.memo(Body);
+MemoBody.displayName = 'Body';
+export default MemoBody;

package/es/table/baseTable/Cell/index.d.ts

@@ -0,0 +1,39 @@
+import * as React from 'react';
+import type { DataIndex, ColumnType, CustomizeComponent, DefaultRecordType, AlignType, CellEllipsisType } from '../interface';
+import type { HoverContextProps } from '../context/HoverContext';
+interface InternalCellProps<RecordType extends DefaultRecordType> extends Pick<HoverContextProps, 'onHover'> {
+    prefixCls?: string;
+    className?: string;
+    record?: RecordType;
+    /** `column` index is the real show rowIndex */
+    index?: number;
+    /** the index of the record. For the render(value, record, renderIndex) */
+    renderIndex?: number;
+    dataIndex?: DataIndex;
+    render?: ColumnType<RecordType>['render'];
+    component?: CustomizeComponent;
+    children?: React.ReactNode;
+    colSpan?: number;
+    rowSpan?: number;
+    ellipsis?: CellEllipsisType;
+    align?: AlignType;
+    shouldCellUpdate?: (record: RecordType, prevRecord: RecordType) => boolean;
+    fixLeft?: number | false;
+    fixRight?: number | false;
+    firstFixLeft?: boolean;
+    lastFixLeft?: boolean;
+    firstFixRight?: boolean;
+    lastFixRight?: boolean;
+    /** @private Used for `expandable` with nest tree */
+    appendNode?: React.ReactNode;
+    additionalProps?: React.TdHTMLAttributes<HTMLTableCellElement>;
+    /** @private Fixed for user use `shouldCellUpdate` which block the render */
+    expanded?: boolean;
+    rowType?: 'header' | 'body' | 'footer';
+    isSticky?: boolean;
+    hovering?: boolean;
+}
+export declare type CellProps<RecordType extends DefaultRecordType> = Omit<InternalCellProps<RecordType>, keyof HoverContextProps>;
+/** Inject hover data here, we still wish MemoCell keep simple `shouldCellUpdate` logic */
+declare const WrappedCell: React.ForwardRefExoticComponent<CellProps<any> & React.RefAttributes<any>>;
+export default WrappedCell;

package/es/table/baseTable/Cell/index.js

@@ -0,0 +1,247 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+
+var __rest = this && this.__rest || function (s, e) {
+  var t = {};
+
+  for (var p in s) {
+    if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  }
+
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+
+import * as React from 'react';
+import classNames from 'classnames';
+import shallowEqual from 'shallowequal';
+import { supportRef } from "rc-util/es/ref";
+import { getPathValue, validateValue } from '../utils/valueUtil';
+import StickyContext from '../context/StickyContext';
+import HoverContext from '../context/HoverContext';
+import warning from "rc-util/es/warning";
+/** Check if cell is in hover range */
+
+function inHoverRange(cellStartRow, cellRowSpan, startRow, endRow) {
+  var cellEndRow = cellStartRow + cellRowSpan - 1;
+  return cellStartRow <= endRow && cellEndRow >= startRow;
+}
+
+function isRenderCell(data) {
+  return data && _typeof(data) === 'object' && !Array.isArray(data) && ! /*#__PURE__*/React.isValidElement(data);
+}
+
+function isRefComponent(component) {
+  // String tag component also support ref
+  if (typeof component === 'string') {
+    return true;
+  }
+
+  return supportRef(component);
+}
+
+function Cell(_ref, ref) {
+  var _classNames;
+
+  var prefixCls = _ref.prefixCls,
+      className = _ref.className,
+      record = _ref.record,
+      index = _ref.index,
+      renderIndex = _ref.renderIndex,
+      dataIndex = _ref.dataIndex,
+      render = _ref.render,
+      children = _ref.children,
+      _ref$component = _ref.component,
+      Component = _ref$component === void 0 ? 'td' : _ref$component,
+      colSpan = _ref.colSpan,
+      rowSpan = _ref.rowSpan,
+      fixLeft = _ref.fixLeft,
+      fixRight = _ref.fixRight,
+      firstFixLeft = _ref.firstFixLeft,
+      lastFixLeft = _ref.lastFixLeft,
+      firstFixRight = _ref.firstFixRight,
+      lastFixRight = _ref.lastFixRight,
+      appendNode = _ref.appendNode,
+      _ref$additionalProps = _ref.additionalProps,
+      additionalProps = _ref$additionalProps === void 0 ? {} : _ref$additionalProps,
+      ellipsis = _ref.ellipsis,
+      align = _ref.align,
+      rowType = _ref.rowType,
+      isSticky = _ref.isSticky,
+      hovering = _ref.hovering,
+      onHover = _ref.onHover;
+
+  var _a, _b;
+
+  var cellPrefixCls = "".concat(prefixCls, "-cell");
+  var supportSticky = React.useContext(StickyContext); // ==================== Child Node ====================
+
+  var cellProps;
+  var childNode;
+
+  if (validateValue(children)) {
+    childNode = children;
+  } else {
+    var value = getPathValue(record, dataIndex); // Customize render node
+
+    childNode = value;
+
+    if (render) {
+      var renderData = render(value, record, renderIndex);
+
+      if (isRenderCell(renderData)) {
+        if (process.env.NODE_ENV !== 'production') {
+          warning(false, '`columns.render` return cell props is deprecated with perf issue, please use `onCell` instead.');
+        }
+
+        childNode = renderData.children;
+        cellProps = renderData.props;
+      } else {
+        childNode = renderData;
+      }
+    }
+  } // Not crash if final `childNode` is not validate ReactNode
+
+
+  if (_typeof(childNode) === 'object' && !Array.isArray(childNode) && ! /*#__PURE__*/React.isValidElement(childNode)) {
+    childNode = null;
+  }
+
+  if (ellipsis && (lastFixLeft || firstFixRight)) {
+    childNode = /*#__PURE__*/React.createElement("span", {
+      className: "".concat(cellPrefixCls, "-content")
+    }, childNode);
+  }
+
+  var _c = cellProps || {},
+      cellColSpan = _c.colSpan,
+      cellRowSpan = _c.rowSpan,
+      cellStyle = _c.style,
+      cellClassName = _c.className,
+      restCellProps = __rest(_c, ["colSpan", "rowSpan", "style", "className"]);
+
+  var mergedColSpan = (_a = cellColSpan !== undefined ? cellColSpan : colSpan) !== null && _a !== void 0 ? _a : 1;
+  var mergedRowSpan = (_b = cellRowSpan !== undefined ? cellRowSpan : rowSpan) !== null && _b !== void 0 ? _b : 1;
+
+  if (mergedColSpan === 0 || mergedRowSpan === 0) {
+    return null;
+  } // ====================== Fixed =======================
+
+
+  var fixedStyle = {};
+  var isFixLeft = typeof fixLeft === 'number' && supportSticky;
+  var isFixRight = typeof fixRight === 'number' && supportSticky;
+
+  if (isFixLeft) {
+    fixedStyle.position = 'sticky';
+    fixedStyle.left = fixLeft;
+  }
+
+  if (isFixRight) {
+    fixedStyle.position = 'sticky';
+    fixedStyle.right = fixRight;
+  } // ====================== Align =======================
+
+
+  var alignStyle = {};
+
+  if (align) {
+    alignStyle.textAlign = align;
+  } // ====================== Hover =======================
+
+
+  var onMouseEnter = function onMouseEnter(event) {
+    var _a;
+
+    if (record) {
+      onHover(index, index + mergedRowSpan - 1);
+    }
+
+    (_a = additionalProps === null || additionalProps === void 0 ? void 0 : additionalProps.onMouseEnter) === null || _a === void 0 ? void 0 : _a.call(additionalProps, event);
+  };
+
+  var onMouseLeave = function onMouseLeave(event) {
+    var _a;
+
+    if (record) {
+      onHover(-1, -1);
+    }
+
+    (_a = additionalProps === null || additionalProps === void 0 ? void 0 : additionalProps.onMouseLeave) === null || _a === void 0 ? void 0 : _a.call(additionalProps, event);
+  }; // ====================== Render ======================
+
+
+  var title;
+  var ellipsisConfig = ellipsis === true ? {
+    showTitle: true
+  } : ellipsis;
+
+  if (ellipsisConfig && (ellipsisConfig.showTitle || rowType === 'header')) {
+    if (typeof childNode === 'string' || typeof childNode === 'number') {
+      title = childNode.toString();
+    } else if ( /*#__PURE__*/React.isValidElement(childNode) && typeof childNode.props.children === 'string') {
+      title = childNode.props.children;
+    }
+  }
+
+  var componentProps = _extends(_extends(_extends({
+    title: title
+  }, restCellProps), additionalProps), {
+    colSpan: mergedColSpan !== 1 ? mergedColSpan : null,
+    rowSpan: mergedRowSpan !== 1 ? mergedRowSpan : null,
+    className: classNames(cellPrefixCls, className, (_classNames = {}, _defineProperty(_classNames, "".concat(cellPrefixCls, "-fix-left"), isFixLeft && supportSticky), _defineProperty(_classNames, "".concat(cellPrefixCls, "-fix-left-first"), firstFixLeft && supportSticky), _defineProperty(_classNames, "".concat(cellPrefixCls, "-fix-left-last"), lastFixLeft && supportSticky), _defineProperty(_classNames, "".concat(cellPrefixCls, "-fix-right"), isFixRight && supportSticky), _defineProperty(_classNames, "".concat(cellPrefixCls, "-fix-right-first"), firstFixRight && supportSticky), _defineProperty(_classNames, "".concat(cellPrefixCls, "-fix-right-last"), lastFixRight && supportSticky), _defineProperty(_classNames, "".concat(cellPrefixCls, "-ellipsis"), ellipsis), _defineProperty(_classNames, "".concat(cellPrefixCls, "-with-append"), appendNode), _defineProperty(_classNames, "".concat(cellPrefixCls, "-fix-sticky"), (isFixLeft || isFixRight) && isSticky && supportSticky), _defineProperty(_classNames, "".concat(cellPrefixCls, "-row-hover"), !cellProps && hovering), _classNames), additionalProps.className, cellClassName),
+    style: _extends(_extends(_extends(_extends({}, additionalProps.style), alignStyle), fixedStyle), cellStyle),
+    onMouseEnter: onMouseEnter,
+    onMouseLeave: onMouseLeave,
+    ref: isRefComponent(Component) ? ref : null
+  });
+
+  return /*#__PURE__*/React.createElement(Component, componentProps, appendNode, childNode);
+}
+
+var RefCell = /*#__PURE__*/React.forwardRef(Cell);
+RefCell.displayName = 'Cell';
+var comparePropList = ['expanded', 'className', 'hovering'];
+var MemoCell = /*#__PURE__*/React.memo(RefCell, function (prev, next) {
+  if (next.shouldCellUpdate) {
+    return (// Additional handle of expanded logic
+      comparePropList.every(function (propName) {
+        return prev[propName] === next[propName];
+      }) && // User control update logic
+      !next.shouldCellUpdate(next.record, prev.record)
+    );
+  }
+
+  return shallowEqual(prev, next);
+});
+/** Inject hover data here, we still wish MemoCell keep simple `shouldCellUpdate` logic */
+
+var WrappedCell = /*#__PURE__*/React.forwardRef(function (props, ref) {
+  var _React$useContext = React.useContext(HoverContext),
+      onHover = _React$useContext.onHover,
+      startRow = _React$useContext.startRow,
+      endRow = _React$useContext.endRow;
+
+  var index = props.index,
+      _props$additionalProp = props.additionalProps,
+      additionalProps = _props$additionalProp === void 0 ? {} : _props$additionalProp,
+      colSpan = props.colSpan,
+      rowSpan = props.rowSpan;
+  var cellColSpan = additionalProps.colSpan,
+      cellRowSpan = additionalProps.rowSpan;
+  var mergedColSpan = colSpan !== null && colSpan !== void 0 ? colSpan : cellColSpan;
+  var mergedRowSpan = rowSpan !== null && rowSpan !== void 0 ? rowSpan : cellRowSpan;
+  var hovering = inHoverRange(index, mergedRowSpan || 1, startRow, endRow);
+  return /*#__PURE__*/React.createElement(MemoCell, _extends({}, props, {
+    colSpan: mergedColSpan,
+    rowSpan: mergedRowSpan,
+    hovering: hovering,
+    ref: ref,
+    onHover: onHover
+  }));
+});
+WrappedCell.displayName = 'WrappedCell';
+export default WrappedCell;

package/es/table/baseTable/ColGroup.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import type { ColumnType } from './interface';
+export interface ColGroupProps<RecordType> {
+    colWidths: readonly (number | string)[];
+    columns?: readonly ColumnType<RecordType>[];
+    columCount?: number;
+}
+declare function ColGroup<RecordType>({ colWidths, columns, columCount }: ColGroupProps<RecordType>): JSX.Element;
+export default ColGroup;

package/es/table/baseTable/ColGroup.js

@@ -0,0 +1,52 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+
+var __rest = this && this.__rest || function (s, e) {
+  var t = {};
+
+  for (var p in s) {
+    if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  }
+
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+
+import * as React from 'react';
+import { INTERNAL_COL_DEFINE } from './utils/legacyUtil';
+
+function ColGroup(_ref) {
+  var colWidths = _ref.colWidths,
+      columns = _ref.columns,
+      columCount = _ref.columCount;
+  var cols = [];
+  var len = columCount || columns.length; // Only insert col with width & additional props
+  // Skip if rest col do not have any useful info
+
+  var mustInsert = false;
+
+  for (var i = len - 1; i >= 0; i -= 1) {
+    var width = colWidths[i];
+    var column = columns && columns[i];
+    var additionalProps = column && column[INTERNAL_COL_DEFINE];
+
+    if (width || additionalProps || mustInsert) {
+      var _a = additionalProps || {},
+          columnType = _a.columnType,
+          restAdditionalProps = __rest(_a, ["columnType"]);
+
+      cols.unshift( /*#__PURE__*/React.createElement("col", _extends({
+        key: i,
+        style: {
+          width: width
+        }
+      }, restAdditionalProps)));
+      mustInsert = true;
+    }
+  }
+
+  return /*#__PURE__*/React.createElement("colgroup", null, cols);
+}
+
+export default ColGroup;

package/es/table/baseTable/FixedHolder/index.d.ts

@@ -0,0 +1,21 @@
+import * as React from 'react';
+import type { HeaderProps } from '../Header/Header';
+export interface FixedHeaderProps<RecordType> extends HeaderProps<RecordType> {
+    className: string;
+    noData: boolean;
+    maxContentScroll: boolean;
+    colWidths: readonly number[];
+    columCount: number;
+    direction: 'ltr' | 'rtl';
+    fixHeader: boolean;
+    stickyTopOffset?: number;
+    stickyBottomOffset?: number;
+    stickyClassName?: string;
+    onScroll: (info: {
+        currentTarget: HTMLDivElement;
+        scrollLeft?: number;
+    }) => void;
+    children: (info: HeaderProps<RecordType>) => React.ReactNode;
+}
+declare const FixedHolder: React.ForwardRefExoticComponent<FixedHeaderProps<unknown> & React.RefAttributes<HTMLDivElement>>;
+export default FixedHolder;