@antsoo-lib/components 0.0.1

package/dist/src/steps/style/small.d.ts

@@ -0,0 +1,5 @@
+import { StepsToken } from '.';
+import { CSSObject } from '../../_util/cssinjs';
+import { GenerateStyle } from '../../theme/internal';
+declare const genStepsSmallStyle: GenerateStyle<StepsToken, CSSObject>;
+export default genStepsSmallStyle;

package/dist/src/steps/style/vertical.d.ts

@@ -0,0 +1,5 @@
+import { StepsToken } from '.';
+import { CSSObject } from '../../_util/cssinjs';
+import { GenerateStyle } from '../../theme/internal';
+declare const genStepsVerticalStyle: GenerateStyle<StepsToken, CSSObject>;
+export default genStepsVerticalStyle;

package/dist/src/style/compact-item-vertical.d.ts

@@ -0,0 +1,4 @@
+import { CSSInterpolation } from '../_util/cssinjs';
+import { FullToken } from '../theme/internal';
+import { OverrideComponent } from '../theme/util/genComponentStyleHook';
+export declare function genCompactItemVerticalStyle<T extends OverrideComponent>(token: FullToken<T>): CSSInterpolation;

package/dist/src/style/compact-item.d.ts

@@ -0,0 +1,18 @@
+import { CSSInterpolation } from '../_util/cssinjs';
+import { FullToken } from '../theme/internal';
+import { OverrideComponent } from '../theme/util/genComponentStyleHook';
+interface CompactItemOptions {
+    focus?: boolean;
+    /**
+     * Some component borders are implemented on child elements
+     * like `Select`
+     */
+    borderElCls?: string;
+    /**
+     * Some components have special `focus` className especially with popovers
+     * like `Select` and `DatePicker`
+     */
+    focusElCls?: string;
+}
+export declare function genCompactItemStyle<T extends OverrideComponent>(token: FullToken<T>, options?: CompactItemOptions): CSSInterpolation;
+export {};

package/dist/src/style/index.d.ts

@@ -0,0 +1,13 @@
+import { CSSObject } from '../_util/cssinjs';
+import { DerivativeToken } from '../theme/internal';
+export { operationUnit } from './operationUnit';
+export { roundedArrow } from './roundedArrow';
+export { genPresetColor } from './presetColor';
+export declare const textEllipsis: CSSObject;
+export declare const resetComponent: (token: DerivativeToken) => CSSObject;
+export declare const resetIcon: () => CSSObject;
+export declare const clearFix: () => CSSObject;
+export declare const genLinkStyle: (token: DerivativeToken) => CSSObject;
+export declare const genCommonStyle: (token: DerivativeToken, componentPrefixCls: string) => CSSObject;
+export declare const genFocusOutline: (token: DerivativeToken) => CSSObject;
+export declare const genFocusStyle: (token: DerivativeToken) => CSSObject;

package/dist/src/style/motion/collapse.d.ts

@@ -0,0 +1,4 @@
+import { AliasToken, GenerateStyle } from '../../theme/internal';
+import { TokenWithCommonCls } from '../../theme/util/genComponentStyleHook';
+declare const genCollapseMotion: GenerateStyle<TokenWithCommonCls<AliasToken>>;
+export default genCollapseMotion;

package/dist/src/style/motion/fade.d.ts

@@ -0,0 +1,6 @@
+import { CSSInterpolation, Keyframes } from '../../_util/cssinjs';
+import { AliasToken } from '../../theme/internal';
+import { TokenWithCommonCls } from '../../theme/util/genComponentStyleHook';
+export declare const fadeIn: Keyframes;
+export declare const fadeOut: Keyframes;
+export declare const initFadeMotion: (token: TokenWithCommonCls<AliasToken>, sameLevel?: boolean) => CSSInterpolation;

package/dist/src/style/motion/index.d.ts

@@ -0,0 +1,6 @@
+import { default as genCollapseMotion } from './collapse';
+import { fadeIn, fadeOut, initFadeMotion } from './fade';
+import { initMoveMotion, moveDownIn, moveDownOut, moveLeftIn, moveLeftOut, moveRightIn, moveRightOut, moveUpIn, moveUpOut } from './move';
+import { initSlideMotion, slideDownIn, slideDownOut, slideLeftIn, slideLeftOut, slideRightIn, slideRightOut, slideUpIn, slideUpOut } from './slide';
+import { initZoomMotion, zoomBigIn, zoomBigOut, zoomDownIn, zoomDownOut, zoomIn, zoomLeftIn, zoomLeftOut, zoomOut, zoomRightIn, zoomRightOut, zoomUpIn, zoomUpOut } from './zoom';
+export { fadeIn, fadeOut, genCollapseMotion, initFadeMotion, initMoveMotion, initSlideMotion, initZoomMotion, moveDownIn, moveDownOut, moveLeftIn, moveLeftOut, moveRightIn, moveRightOut, moveUpIn, moveUpOut, slideDownIn, slideDownOut, slideLeftIn, slideLeftOut, slideRightIn, slideRightOut, slideUpIn, slideUpOut, zoomBigIn, zoomBigOut, zoomDownIn, zoomDownOut, zoomIn, zoomLeftIn, zoomLeftOut, zoomOut, zoomRightIn, zoomRightOut, zoomUpIn, zoomUpOut, };

package/dist/src/style/motion/motion.d.ts

@@ -0,0 +1,2 @@
+import { CSSObject, Keyframes } from '../../_util/cssinjs';
+export declare const initMotion: (motionCls: string, inKeyframes: Keyframes, outKeyframes: Keyframes, duration: string, sameLevel?: boolean) => CSSObject;

package/dist/src/style/motion/move.d.ts

@@ -0,0 +1,14 @@
+import { CSSInterpolation, Keyframes } from '../../_util/cssinjs';
+import { AliasToken } from '../../theme/internal';
+import { TokenWithCommonCls } from '../../theme/util/genComponentStyleHook';
+export declare const moveDownIn: Keyframes;
+export declare const moveDownOut: Keyframes;
+export declare const moveLeftIn: Keyframes;
+export declare const moveLeftOut: Keyframes;
+export declare const moveRightIn: Keyframes;
+export declare const moveRightOut: Keyframes;
+export declare const moveUpIn: Keyframes;
+export declare const moveUpOut: Keyframes;
+type MoveMotionTypes = 'move-up' | 'move-down' | 'move-left' | 'move-right';
+export declare const initMoveMotion: (token: TokenWithCommonCls<AliasToken>, motionName: MoveMotionTypes) => CSSInterpolation;
+export {};

package/dist/src/style/motion/slide.d.ts

@@ -0,0 +1,14 @@
+import { CSSInterpolation, Keyframes } from '../../_util/cssinjs';
+import { AliasToken } from '../../theme/internal';
+import { TokenWithCommonCls } from '../../theme/util/genComponentStyleHook';
+export declare const slideUpIn: Keyframes;
+export declare const slideUpOut: Keyframes;
+export declare const slideDownIn: Keyframes;
+export declare const slideDownOut: Keyframes;
+export declare const slideLeftIn: Keyframes;
+export declare const slideLeftOut: Keyframes;
+export declare const slideRightIn: Keyframes;
+export declare const slideRightOut: Keyframes;
+type SlideMotionTypes = 'slide-up' | 'slide-down' | 'slide-left' | 'slide-right';
+export declare const initSlideMotion: (token: TokenWithCommonCls<AliasToken>, motionName: SlideMotionTypes) => CSSInterpolation;
+export {};

package/dist/src/style/motion/zoom.d.ts

@@ -0,0 +1,18 @@
+import { CSSInterpolation, Keyframes } from '../../_util/cssinjs';
+import { AliasToken } from '../../theme/internal';
+import { TokenWithCommonCls } from '../../theme/util/genComponentStyleHook';
+export declare const zoomIn: Keyframes;
+export declare const zoomOut: Keyframes;
+export declare const zoomBigIn: Keyframes;
+export declare const zoomBigOut: Keyframes;
+export declare const zoomUpIn: Keyframes;
+export declare const zoomUpOut: Keyframes;
+export declare const zoomLeftIn: Keyframes;
+export declare const zoomLeftOut: Keyframes;
+export declare const zoomRightIn: Keyframes;
+export declare const zoomRightOut: Keyframes;
+export declare const zoomDownIn: Keyframes;
+export declare const zoomDownOut: Keyframes;
+type ZoomMotionTypes = 'zoom' | 'zoom-big' | 'zoom-big-fast' | 'zoom-left' | 'zoom-right' | 'zoom-up' | 'zoom-down';
+export declare const initZoomMotion: (token: TokenWithCommonCls<AliasToken>, motionName: ZoomMotionTypes) => CSSInterpolation;
+export {};

package/dist/src/style/operationUnit.d.ts

@@ -0,0 +1,3 @@
+import { CSSObject } from '../_util/cssinjs';
+import { DerivativeToken } from '../theme/internal';
+export declare const operationUnit: (token: DerivativeToken) => CSSObject;

package/dist/src/style/placementArrow.d.ts

@@ -0,0 +1,19 @@
+import { CSSInterpolation } from '../_util/cssinjs';
+import { AliasToken } from '../theme/internal';
+import { TokenWithCommonCls } from '../theme/util/genComponentStyleHook';
+export declare const MAX_VERTICAL_CONTENT_RADIUS = 8;
+export declare function getArrowOffset(options: {
+    sizePopupArrow: number;
+    contentRadius: number;
+    borderRadiusOuter: number;
+    limitVerticalRadius?: boolean;
+}): {
+    dropdownArrowOffset: number;
+    dropdownArrowOffsetVertical: number;
+};
+export default function getArrowStyle<Token extends TokenWithCommonCls<AliasToken>>(token: Token, options: {
+    colorBg: string;
+    showArrowCls?: string;
+    contentRadius?: number;
+    limitVerticalRadius?: boolean;
+}): CSSInterpolation;

package/dist/src/style/presetColor.d.ts

@@ -0,0 +1,16 @@
+import { CSSObject } from '../_util/cssinjs';
+import { AliasToken, PresetColorKey } from '../theme/internal';
+import { TokenWithCommonCls } from '../theme/util/genComponentStyleHook';
+interface CalcColor {
+    /** token[`${colorKey}-1`] */
+    lightColor: string;
+    /** token[`${colorKey}-3`] */
+    lightBorderColor: string;
+    /** token[`${colorKey}-6`] */
+    darkColor: string;
+    /** token[`${colorKey}-7`] */
+    textColor: string;
+}
+type GenCSS = (colorKey: PresetColorKey, calcColor: CalcColor) => CSSObject;
+export declare function genPresetColor<Token extends TokenWithCommonCls<AliasToken>>(token: Token, genCss: GenCSS): CSSObject;
+export {};

package/dist/src/style/roundedArrow.d.ts

@@ -0,0 +1,2 @@
+import { CSSObject } from '../_util/cssinjs';
+export declare const roundedArrow: (width: number, innerRadius: number, outerRadius: number, bgColor: string, boxShadow: string) => CSSObject;

package/dist/src/switch/style/index.d.ts

@@ -0,0 +1,4 @@
+import { Ref } from 'vue';
+import { UseComponentStyleResult } from '../../theme/internal';
+declare const _default: (_prefixCls?: Ref<string>) => UseComponentStyleResult;
+export default _default;

package/dist/src/table/Column.d.ts

@@ -0,0 +1,5 @@
+import { ColumnType } from './interface';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export type ColumnProps<RecordType = unknown> = ColumnType<RecordType>;
+declare const _default: DefineComponent<ColumnProps<unknown>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ColumnProps<unknown>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/src/table/ColumnGroup.d.ts

@@ -0,0 +1,4 @@
+import { ColumnGroupProps } from '../vc-table/sugar/ColumnGroup';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+declare const _default: DefineComponent<ColumnGroupProps<any>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ColumnGroupProps<any>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/src/table/ExpandIcon.d.ts

@@ -0,0 +1,10 @@
+import { TableLocale } from './interface';
+interface DefaultExpandIconProps<RecordType> {
+    prefixCls: string;
+    onExpand: (record: RecordType, e: MouseEvent) => void;
+    record: RecordType;
+    expanded: boolean;
+    expandable: boolean;
+}
+declare function renderExpandIcon(locale: TableLocale): <RecordType>({ prefixCls, onExpand, record, expanded, expandable, }: DefaultExpandIconProps<RecordType>) => import("vue/jsx-runtime").JSX.Element;
+export default renderExpandIcon;

package/dist/src/table/context.d.ts

@@ -0,0 +1,24 @@
+import { ComputedRef } from 'vue';
+import { ColumnType } from './interface';
+export interface ContextSlots {
+    emptyText?: (...args: any[]) => any;
+    expandIcon?: (...args: any[]) => any;
+    title?: (...args: any[]) => any;
+    footer?: (...args: any[]) => any;
+    summary?: (...args: any[]) => any;
+    bodyCell?: (...args: any[]) => any;
+    expandColumnTitle?: (...args: any[]) => any;
+    headerCell?: (...args: any[]) => any;
+    customFilterIcon?: (...args: any[]) => any;
+    customFilterDropdown?: (...args: any[]) => any;
+    [key: string]: ((...args: any[]) => any) | undefined;
+}
+type SlotsContextProps = ComputedRef<ContextSlots>;
+export declare const useProvideSlots: (props: SlotsContextProps) => void;
+export declare const useInjectSlots: () => SlotsContextProps;
+interface ContextProps {
+    onResizeColumn: (w: number, column: ColumnType<any>) => void;
+}
+export declare const useProvideTableContext: (props: ContextProps) => void;
+export declare const useInjectTableContext: () => ContextProps;
+export {};

package/dist/src/table/hooks/useColumns.d.ts

@@ -0,0 +1,4 @@
+import { Ref } from 'vue';
+import { ContextSlots } from '../context';
+import { TransformColumns } from '../interface';
+export default function useColumns<RecordType>(contextSlots: Ref<ContextSlots>): [TransformColumns<RecordType>];

package/dist/src/table/hooks/useFilter/FilterDropdown.d.ts

@@ -0,0 +1,21 @@
+import { FilterState } from '.';
+import { ColumnFilterItem, ColumnType, FilterSearchType, GetPopupContainer, Key, TableLocale } from '../../interface';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export type TreeColumnFilterItem = ColumnFilterItem;
+export interface FilterDropdownProps<RecordType> {
+    tablePrefixCls: string;
+    prefixCls: string;
+    dropdownPrefixCls: string;
+    column: ColumnType<RecordType>;
+    filterState?: FilterState<RecordType>;
+    filterMultiple: boolean;
+    filterMode?: 'menu' | 'tree';
+    filterSearch?: FilterSearchType<ColumnFilterItem | TreeColumnFilterItem>;
+    columnKey: Key;
+    triggerFilter: (filterState: FilterState<RecordType>) => void;
+    locale: TableLocale;
+    getPopupContainer?: GetPopupContainer;
+    filterResetToDefaultFilteredValue?: boolean;
+}
+declare const _default: DefineComponent<FilterDropdownProps<any>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<FilterDropdownProps<any>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/src/table/hooks/useFilter/FilterSearch.d.ts

@@ -0,0 +1,52 @@
+import { FilterSearchType, TableLocale } from '../../interface';
+import { DefineComponent, ExtractPropTypes, PropType, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+declare const _default: DefineComponent<ExtractPropTypes<{
+    value: {
+        type: PropType<string>;
+        default: string;
+    };
+    onChange: {
+        type: PropType<(e: InputEvent) => void>;
+        default: (e: InputEvent) => void;
+    };
+    filterSearch: {
+        type: PropType<FilterSearchType>;
+        default: FilterSearchType;
+    };
+    tablePrefixCls: {
+        type: PropType<string>;
+        default: string;
+    };
+    locale: {
+        type: PropType<TableLocale>;
+        default: TableLocale;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element | null, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
+    value: {
+        type: PropType<string>;
+        default: string;
+    };
+    onChange: {
+        type: PropType<(e: InputEvent) => void>;
+        default: (e: InputEvent) => void;
+    };
+    filterSearch: {
+        type: PropType<FilterSearchType>;
+        default: FilterSearchType;
+    };
+    tablePrefixCls: {
+        type: PropType<string>;
+        default: string;
+    };
+    locale: {
+        type: PropType<TableLocale>;
+        default: TableLocale;
+    };
+}>> & Readonly<{}>, {
+    value: string;
+    onChange: (e: InputEvent) => void;
+    locale: TableLocale;
+    filterSearch: FilterSearchType;
+    tablePrefixCls: string;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/src/table/hooks/useFilter/FilterWrapper.d.ts

@@ -0,0 +1,4 @@
+declare const FilterDropdownMenuWrapper: (_props: any, { slots }: {
+    slots: any;
+}) => import("vue/jsx-runtime").JSX.Element;
+export default FilterDropdownMenuWrapper;

package/dist/src/table/hooks/useFilter/index.d.ts

@@ -0,0 +1,25 @@
+import { Ref } from 'vue';
+import { DefaultRecordType } from '../../../vc-table/interface';
+import { ColumnFilterItem, ColumnType, ColumnsType, FilterKey, FilterValue, GetPopupContainer, Key, TableLocale, TransformColumns } from '../../interface';
+export interface FilterState<RecordType = DefaultRecordType> {
+    column: ColumnType<RecordType>;
+    key: Key;
+    filteredKeys?: FilterKey;
+    forceFiltered?: boolean;
+}
+export declare function flattenKeys(filters?: ColumnFilterItem[]): FilterValue;
+export declare function getFilterData<RecordType>(data: RecordType[], filterStates: FilterState<RecordType>[]): RecordType[];
+interface FilterConfig<RecordType> {
+    prefixCls: Ref<string>;
+    dropdownPrefixCls: Ref<string>;
+    mergedColumns: Ref<ColumnsType<RecordType>>;
+    locale: Ref<TableLocale>;
+    onFilterChange: (filters: Record<string, FilterValue | null>, filterStates: FilterState<RecordType>[]) => void;
+    getPopupContainer?: Ref<GetPopupContainer>;
+}
+declare function useFilter<RecordType>({ prefixCls, dropdownPrefixCls, mergedColumns: rawMergedColumns, locale, onFilterChange, getPopupContainer, }: FilterConfig<RecordType>): [
+    TransformColumns<RecordType>,
+    Ref<FilterState<RecordType>[]>,
+    Ref<Record<string, FilterValue | null>>
+];
+export default useFilter;

package/dist/src/table/hooks/useLazyKVMap.d.ts

@@ -0,0 +1,3 @@
+import { Ref } from 'vue';
+import { GetRowKey, Key } from '../interface';
+export default function useLazyKVMap<RecordType>(dataRef: Ref<readonly RecordType[]>, childrenColumnNameRef: Ref<string>, getRowKeyRef: Ref<GetRowKey<RecordType>>): ((key: Key) => RecordType)[];

package/dist/src/table/hooks/usePagination.d.ts

@@ -0,0 +1,5 @@
+import { Ref } from 'vue';
+import { TablePaginationConfig } from '../interface';
+export declare const DEFAULT_PAGE_SIZE = 10;
+export declare function getPaginationParam(mergedPagination: TablePaginationConfig, pagination: TablePaginationConfig | boolean | undefined): any;
+export default function usePagination(totalRef: Ref<number>, paginationRef: Ref<TablePaginationConfig | false | undefined>, onChange: (current: number, pageSize: number) => void): [Ref<TablePaginationConfig>, () => void];

package/dist/src/table/hooks/useSelection.d.ts

@@ -0,0 +1,20 @@
+import { Ref } from 'vue';
+import { ExpandType, GetPopupContainer, GetRowKey, Key, SelectionItem, TableLocale, TableRowSelection, TransformColumns } from '../interface';
+export declare const SELECTION_COLUMN: {};
+export declare const SELECTION_ALL: "SELECT_ALL";
+export declare const SELECTION_INVERT: "SELECT_INVERT";
+export declare const SELECTION_NONE: "SELECT_NONE";
+interface UseSelectionConfig<RecordType> {
+    prefixCls: Ref<string>;
+    pageData: Ref<RecordType[]>;
+    data: Ref<RecordType[]>;
+    getRowKey: Ref<GetRowKey<RecordType>>;
+    getRecordByKey: (key: Key) => RecordType;
+    expandType: Ref<ExpandType>;
+    childrenColumnName: Ref<string>;
+    locale: Ref<TableLocale>;
+    getPopupContainer?: Ref<GetPopupContainer>;
+}
+export type INTERNAL_SELECTION_ITEM = SelectionItem | typeof SELECTION_ALL | typeof SELECTION_INVERT | typeof SELECTION_NONE;
+export default function useSelection<RecordType>(rowSelectionRef: Ref<TableRowSelection<RecordType> | undefined>, configRef: UseSelectionConfig<RecordType>): [TransformColumns<RecordType>, Ref<Set<Key>>];
+export {};

package/dist/src/table/hooks/useSorter.d.ts

@@ -0,0 +1,26 @@
+import { Ref } from 'vue';
+import { TooltipProps } from '../../tooltip';
+import { DefaultRecordType } from '../../vc-table/interface';
+import { ColumnTitleProps, ColumnType, ColumnsType, Key, SortOrder, SorterResult, TableLocale, TransformColumns } from '../interface';
+export interface SortState<RecordType = DefaultRecordType> {
+    column: ColumnType<RecordType>;
+    key: Key;
+    sortOrder: SortOrder | null;
+    multiplePriority: number | false;
+}
+export declare function getSortData<RecordType>(data: readonly RecordType[], sortStates: SortState<RecordType>[], childrenColumnName: string): RecordType[];
+interface SorterConfig<RecordType> {
+    prefixCls: Ref<string>;
+    mergedColumns: Ref<ColumnsType<RecordType>>;
+    onSorterChange: (sorterResult: SorterResult<RecordType> | SorterResult<RecordType>[], sortStates: SortState<RecordType>[]) => void;
+    sortDirections: Ref<SortOrder[]>;
+    tableLocale?: Ref<TableLocale>;
+    showSorterTooltip?: Ref<boolean | TooltipProps>;
+}
+export default function useFilterSorter<RecordType>({ prefixCls, mergedColumns, onSorterChange, sortDirections, tableLocale, showSorterTooltip, }: SorterConfig<RecordType>): [
+    TransformColumns<RecordType>,
+    Ref<SortState<RecordType>[]>,
+    Ref<ColumnTitleProps<RecordType>>,
+    Ref<SorterResult<RecordType> | SorterResult<RecordType>[]>
+];
+export {};

package/dist/src/table/hooks/useTitleColumns.d.ts

@@ -0,0 +1,3 @@
+import { Ref } from 'vue';
+import { ColumnTitleProps, TransformColumns } from '../interface';
+export default function useTitleColumns<RecordType>(columnTitleProps: Ref<ColumnTitleProps<RecordType>>): [TransformColumns<RecordType>];

package/dist/src/table/interface.d.ts

@@ -0,0 +1,166 @@
+import { CSSProperties, VNodeArrayChildren } from 'vue';
+import { Breakpoint } from '../_util/responsiveObserve';
+import { VueNode } from '../_util/type';
+import { CheckboxProps } from '../checkbox';
+import { PaginationProps } from '../pagination';
+import { TooltipProps } from '../tooltip';
+import { DefaultRecordType, ExpandableConfig, FixedType, GetRowKey, ColumnType as RcColumnType, RenderedCell as RcRenderedCell } from '../vc-table/interface';
+import { INTERNAL_SELECTION_ITEM } from './hooks/useSelection';
+export type { ExpandableConfig, GetRowKey };
+export type Key = string | number;
+export type RowSelectionType = 'checkbox' | 'radio';
+export type SelectionItemSelectFn = (currentRowKeys: Key[]) => void;
+export type ExpandType = null | 'row' | 'nest';
+export interface TableLocale {
+    filterTitle?: string;
+    filterConfirm?: any;
+    filterReset?: any;
+    filterEmptyText?: any;
+    filterCheckall?: any;
+    filterSearchPlaceholder?: any;
+    emptyText?: any | (() => any);
+    selectAll?: any;
+    selectNone?: any;
+    selectInvert?: any;
+    selectionAll?: any;
+    sortTitle?: string;
+    expand?: string;
+    collapse?: string;
+    triggerDesc?: string;
+    triggerAsc?: string;
+    cancelSort?: string;
+}
+export type SortOrder = 'descend' | 'ascend' | null;
+declare const TableActions: ["paginate", "sort", "filter"];
+export type TableAction = (typeof TableActions)[number];
+export type CompareFn<T> = (a: T, b: T, sortOrder?: SortOrder) => number;
+export interface ColumnFilterItem {
+    text: VueNode;
+    value: string | number | boolean;
+    children?: ColumnFilterItem[];
+}
+export interface ColumnTitleProps<RecordType> {
+    /** @deprecated Please use `sorterColumns` instead. */
+    sortOrder?: SortOrder;
+    /** @deprecated Please use `sorterColumns` instead. */
+    sortColumn?: ColumnType<RecordType>;
+    sortColumns?: {
+        column: ColumnType<RecordType>;
+        order: SortOrder;
+    }[];
+    filters?: Record<string, FilterValue>;
+}
+type ColumnTitleNode = VueNode | VNodeArrayChildren;
+export type ColumnTitle<RecordType> = ColumnTitleNode | ((props: ColumnTitleProps<RecordType>) => ColumnTitleNode);
+export type FilterValue = (Key | boolean)[];
+export type FilterKey = Key[] | null;
+export type FilterSearchType<RecordType = Record<string, any>> = boolean | ((input: string, record: RecordType) => boolean);
+export interface FilterConfirmProps {
+    closeDropdown: boolean;
+}
+export interface FilterResetProps {
+    confirm?: boolean;
+    closeDropdown?: boolean;
+}
+export interface FilterDropdownProps<RecordType> {
+    prefixCls: string;
+    setSelectedKeys: (selectedKeys: Key[]) => void;
+    selectedKeys: Key[];
+    confirm: (param?: FilterConfirmProps) => void;
+    clearFilters?: (param?: FilterResetProps) => void;
+    filters?: ColumnFilterItem[];
+    /** Only close filterDropdown */
+    close: () => void;
+    visible: boolean;
+    column: ColumnType<RecordType>;
+}
+export interface ColumnType<RecordType = DefaultRecordType> extends Omit<RcColumnType<RecordType>, 'title'> {
+    title?: ColumnTitle<RecordType>;
+    sorter?: boolean | CompareFn<RecordType> | {
+        compare?: CompareFn<RecordType>;
+        /** Config multiple sorter order priority */
+        multiple?: number;
+    };
+    sortOrder?: SortOrder;
+    defaultSortOrder?: SortOrder;
+    sortDirections?: SortOrder[];
+    showSorterTooltip?: boolean | TooltipProps;
+    filtered?: boolean;
+    filters?: ColumnFilterItem[];
+    filterDropdown?: VueNode | ((props: FilterDropdownProps<RecordType>) => VueNode);
+    filterMultiple?: boolean;
+    filteredValue?: FilterValue | null;
+    defaultFilteredValue?: FilterValue | null;
+    filterIcon?: VueNode | ((opt: {
+        filtered: boolean;
+        column: ColumnType;
+    }) => VueNode);
+    filterMode?: 'menu' | 'tree';
+    filterSearch?: FilterSearchType<ColumnFilterItem>;
+    onFilter?: (value: string | number | boolean, record: RecordType) => boolean;
+    filterDropdownOpen?: boolean;
+    onFilterDropdownOpenChange?: (visible: boolean) => void;
+    filterResetToDefaultFilteredValue?: boolean;
+    responsive?: Breakpoint[];
+    /** @deprecated Please use `filterDropdownOpen` instead */
+    filterDropdownVisible?: boolean;
+    /** @deprecated Please use `onFilterDropdownOpenChange` instead */
+    onFilterDropdownVisibleChange?: (visible: boolean) => void;
+}
+export interface ColumnGroupType<RecordType> extends Omit<ColumnType<RecordType>, 'dataIndex'> {
+    children: ColumnsType<RecordType>;
+}
+export type ColumnsType<RecordType = DefaultRecordType> = (ColumnGroupType<RecordType> | ColumnType<RecordType>)[];
+export interface SelectionItem {
+    key: string;
+    text: VueNode;
+    onSelect?: SelectionItemSelectFn;
+}
+export type SelectionSelectFn<T> = (record: T, selected: boolean, selectedRows: T[], nativeEvent: Event) => void;
+export interface TableRowSelection<T = DefaultRecordType> {
+    /** Keep the selection keys in list even the key not exist in `dataSource` anymore */
+    preserveSelectedRowKeys?: boolean;
+    type?: RowSelectionType;
+    selectedRowKeys?: Key[];
+    defaultSelectedRowKeys?: Key[];
+    onChange?: (selectedRowKeys: Key[], selectedRows: T[]) => void;
+    getCheckboxProps?: (record: T) => Partial<Omit<CheckboxProps, 'checked' | 'defaultChecked'>>;
+    onSelect?: SelectionSelectFn<T>;
+    onSelectMultiple?: (selected: boolean, selectedRows: T[], changeRows: T[]) => void;
+    /** @deprecated This function is meaningless and should use `onChange` instead */
+    onSelectAll?: (selected: boolean, selectedRows: T[], changeRows: T[]) => void;
+    /** @deprecated This function is meaningless and should use `onChange` instead */
+    onSelectInvert?: (selectedRowKeys: Key[]) => void;
+    onSelectNone?: () => void;
+    selections?: INTERNAL_SELECTION_ITEM[] | boolean;
+    hideSelectAll?: boolean;
+    fixed?: FixedType;
+    columnWidth?: string | number;
+    columnTitle?: string | VueNode;
+    checkStrictly?: boolean;
+    renderCell?: (value: boolean, record: T, index: number, originNode: VueNode) => VueNode | RcRenderedCell<T>;
+}
+export type TransformColumns<RecordType> = (columns: ColumnsType<RecordType>) => ColumnsType<RecordType>;
+export interface TableCurrentDataSource<RecordType = DefaultRecordType> {
+    currentDataSource: RecordType[];
+    action: TableAction;
+}
+export interface SorterResult<RecordType = DefaultRecordType> {
+    column?: ColumnType<RecordType>;
+    order?: SortOrder;
+    field?: Key | readonly Key[];
+    columnKey?: Key;
+}
+export type GetPopupContainer = (triggerNode: HTMLElement) => HTMLElement;
+type TablePaginationPosition = 'topLeft' | 'topCenter' | 'topRight' | 'bottomLeft' | 'bottomCenter' | 'bottomRight';
+export interface TablePaginationConfig extends PaginationProps {
+    position?: TablePaginationPosition[];
+    class?: string;
+    style?: CSSProperties;
+}
+export interface TransformCellTextProps {
+    text: any;
+    column: ColumnType;
+    record: any;
+    index: number;
+}

package/dist/src/table/style/bordered.d.ts

@@ -0,0 +1,5 @@
+import { CSSObject } from '../../_util/cssinjs';
+import { GenerateStyle } from '../../theme/internal';
+import { TableToken } from './index';
+declare const genBorderedStyle: GenerateStyle<TableToken, CSSObject>;
+export default genBorderedStyle;

package/dist/src/table/style/ellipsis.d.ts

@@ -0,0 +1,5 @@
+import { CSSObject } from '../../_util/cssinjs';
+import { GenerateStyle } from '../../theme/internal';
+import { TableToken } from './index';
+declare const genEllipsisStyle: GenerateStyle<TableToken, CSSObject>;
+export default genEllipsisStyle;

package/dist/src/table/style/empty.d.ts

@@ -0,0 +1,5 @@
+import { CSSObject } from '../../_util/cssinjs';
+import { GenerateStyle } from '../../theme/internal';
+import { TableToken } from './index';
+declare const genEmptyStyle: GenerateStyle<TableToken, CSSObject>;
+export default genEmptyStyle;

package/dist/src/table/style/expand.d.ts

@@ -0,0 +1,5 @@
+import { CSSObject } from '../../_util/cssinjs';
+import { GenerateStyle } from '../../theme/internal';
+import { TableToken } from './index';
+declare const genExpandStyle: GenerateStyle<TableToken, CSSObject>;
+export default genExpandStyle;

package/dist/src/table/style/filter.d.ts

@@ -0,0 +1,4 @@
+import { GenerateStyle } from '../../theme/internal';
+import { TableToken } from './index';
+declare const genFilterStyle: GenerateStyle<TableToken>;
+export default genFilterStyle;

package/dist/src/table/style/fixed.d.ts

@@ -0,0 +1,5 @@
+import { CSSObject } from '../../_util/cssinjs';
+import { GenerateStyle } from '../../theme/internal';
+import { TableToken } from './index';
+declare const genFixedStyle: GenerateStyle<TableToken, CSSObject>;
+export default genFixedStyle;