@maxax/ui 1.0.0

package/dist/components/basic-table/BasicTable.vue.d.ts

@@ -0,0 +1,322 @@
+import { BasicTableEmitType, BasicTableProps, VxeGridInstance } from './interface';
+
+declare function __VLS_template(): Partial<Record<string, (_: {
+    [key: string]: any;
+    $table: import('vxe-table').VxeTableConstructor<any>;
+    $grid: import('vxe-table').VxeGridConstructor<any> | null | undefined;
+    rowid: string;
+    row: any;
+    rowIndex: number;
+    $rowIndex: number;
+    _rowIndex: number;
+    column: import("vxe-table").VxeTableDefines.ColumnInfo<any>;
+    columnIndex: number;
+    $columnIndex: number;
+    _columnIndex: number;
+    type: string;
+    fixed: import("vxe-table").VxeColumnPropTypes.Fixed;
+    checked?: boolean;
+    indeterminate?: boolean;
+    seq: string | number;
+    level: number;
+    isEdit: boolean;
+    isHidden: boolean;
+    field: string;
+    item: any;
+    data: any;
+    visibleData: any[];
+    items: any[];
+}) => any>> & {
+    "selection-wrapper-before"?(_: {}): any;
+    "selection-wrapper-after"?(_: {}): any;
+};
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<BasicTableProps>, any>>, {
+    emit?: BasicTableEmitType;
+    reload: (opt?: import('./interface').FetchParams) => Promise<Array<import('@maxax/types').Recordable<any>> | undefined>;
+    setLoading: (loading: boolean) => void;
+    setProps: (props: Partial<BasicTableProps>) => void;
+    getTableProps: () => BasicTableProps;
+    setPagination: (info: Partial<import('./interface').BasicPagerProps>) => void;
+    getPaginationRef: () => import('./interface').BasicPagerProps | boolean;
+    setShowPagination: (show: boolean) => Promise<void>;
+    getShowPagination: () => boolean;
+    setTableData: <T = import('@maxax/types').Recordable>(values: T[]) => void;
+    getDataSource: <T = import('@maxax/types').Recordable>() => T[];
+    getRawDataSource: <T = import('@maxax/types').Recordable>() => T;
+    getSearchInfo: <T = import('@maxax/types').Recordable>() => T;
+    updateTableDataRecord: (keyValue: import('./interface').Key, record: import('@maxax/types').Recordable) => import('@maxax/types').Recordable | undefined;
+    deleteTableDataRecord: (keyValues: import('./interface').Key | import('./interface').Key[]) => void;
+    insertTableDataRecord: (record: import('@maxax/types').Recordable | import('@maxax/types').Recordable[], index?: number) => import('@maxax/types').Recordable[] | undefined;
+    findTableDataRecord: (keyValue: import('./interface').Key) => import('@maxax/types').Recordable | undefined;
+    updateTableData: (index: number, key: string, value: any) => import('@maxax/types').Recordable;
+    getTableRowKey: () => string | import('./interface').GetRowKey | undefined;
+    mergeTableDataRecord: (records: import('@maxax/types').Recordable[], key: import('@maxax/types').KeyValueType) => void;
+    getColumns: (opt?: import('./interface').GetColumnsParams) => import('./interface').BasicColumn[];
+    setColumns: (columns: import('./interface').BasicColumn[] | string[]) => void;
+    getCacheColumns: () => import('./interface').BasicColumn[];
+    setCacheColumnsByField?: (dataIndex: string | undefined, value: import('./interface').BasicColumn) => void;
+    setCacheColumns?: (columns: import('./interface').BasicColumn[]) => void;
+    setSelectedRowKeys: (keyValues: import('./interface').BasicTableRowKey[]) => void;
+    getRowSelection: () => import('./interface').TableRowSelection<import('@maxax/types').Recordable>;
+    setSelectedRows: (rows: import('@maxax/types').Recordable[]) => void;
+    getSelectRows: <T = import('@maxax/types').Recordable>() => T[];
+    clearSelectedRowKeys: () => void;
+    getSelectRowKeys: () => import('./interface').BasicTableRowKey[];
+    deleteSelectRowByKey: (keyValue: import('./interface').BasicTableRowKey) => void;
+    handleSearchInfoChange: (info?: import('@maxax/types').Recordable) => void;
+    handleSearchInfoReload: (info?: import('@maxax/types').Recordable) => void;
+    setSelection: () => Promise<void>;
+    instance: () => VxeGridInstance | null;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "fetch-success": () => void;
+    "fetch-error": () => void;
+    "selection-change": (params: import('./interface').SelectionChangeEventParams) => void;
+    "page-change": (params: import("vxe-pc-ui").VxePagerDefines.PageChangeEventParams) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<BasicTableProps>, any>>> & Readonly<{
+    "onFetch-success"?: (() => any) | undefined;
+    "onFetch-error"?: (() => any) | undefined;
+    "onPage-change"?: ((params: import("vxe-pc-ui").VxePagerDefines.PageChangeEventParams) => any) | undefined;
+    "onSelection-change"?: ((params: import('./interface').SelectionChangeEventParams) => any) | undefined;
+}>, {
+    height: import("vxe-table").VxeTablePropTypes.Height;
+    maxHeight: import("vxe-table").VxeTablePropTypes.MaxHeight;
+    minHeight: import("vxe-table").VxeTablePropTypes.MinHeight;
+    border: import("vxe-table").VxeTablePropTypes.Border;
+    columns: import("vxe-table").VxeGridPropTypes.Columns<any> & import('./interface').BasicColumn[];
+    padding: import("vxe-table").VxeTablePropTypes.Padding;
+    data: import("vxe-table").VxeTablePropTypes.Data<any>;
+    loading: import("vxe-table").VxeTablePropTypes.Loading;
+    size: import("vxe-table").VxeTablePropTypes.Size;
+    fit: import("vxe-table").VxeTablePropTypes.Fit;
+    showHeader: import("vxe-table").VxeTablePropTypes.ShowHeader;
+    delayHover: import("vxe-table").VxeTablePropTypes.DelayHover;
+    autoResize: import("vxe-table").VxeTablePropTypes.AutoResize;
+    showOverflow: import("vxe-table").VxeTablePropTypes.ShowOverflow;
+    resizable: import("vxe-table").VxeTablePropTypes.Resizable;
+    showHeaderOverflow: import("vxe-table").VxeTablePropTypes.ShowHeaderOverflow;
+    showFooterOverflow: import("vxe-table").VxeTablePropTypes.ShowFooterOverflow;
+    onCopy: import("vxe-table").VxeGridEvents.Copy<any>;
+    onCut: import("vxe-table").VxeGridEvents.Cut<any>;
+    onPaste: import("vxe-table").VxeGridEvents.Paste<any>;
+    onKeydown: import("vxe-table").VxeGridEvents.Keydown<any>;
+    onScroll: import("vxe-table").VxeGridEvents.Scroll<any>;
+    id: import("vxe-table").VxeTablePropTypes.ID<any>;
+    round: import("vxe-table").VxeTablePropTypes.Round;
+    immediate: boolean;
+    api: (...arg: any) => Promise<any>;
+    dynamicApi: (params?: import('@maxax/types').Recordable) => (...arg: any) => Promise<any>;
+    beforeFetch: import('@maxax/types').Fn;
+    afterFetch: import('@maxax/types').Fn;
+    handleSearchInfoFn: import('@maxax/types').Fn;
+    searchInfo: import('@maxax/types').Recordable;
+    fetchSetting: Partial<import('./interface').FetchSetting>;
+    showFooter: import("vxe-table").VxeTablePropTypes.ShowFooter;
+    card: boolean;
+    rKey: string | import('./interface').GetRowKey;
+    defSort: import('@maxax/types').Recordable;
+    useSearchForm: boolean;
+    pagination: import('./interface').BasicPagerProps | boolean;
+    layouts: import("vxe-table").VxeGridPropTypes.Layouts;
+    align: import("vxe-table").VxeTablePropTypes.Align;
+    uid: string;
+    relationForm: () => import('..').FormActionType | null;
+    onPageChange: import("vxe-table").VxeGridEvents.PageChange<any>;
+    onSelection: (params: {
+        selectedRowKeys: import('./interface').Key[];
+        selectedRows: any[];
+    }) => void;
+    pagerConfig: import("vxe-table").VxeGridPropTypes.PagerConfig;
+    proxyConfig: import("vxe-table").VxeGridPropTypes.ProxyConfig<any>;
+    toolbarConfig: import("vxe-table").VxeGridPropTypes.ToolbarConfig;
+    formConfig: import("vxe-table").VxeGridPropTypes.FormConfig;
+    zoomConfig: import("vxe-table").VxeGridPropTypes.ZoomConfig;
+    stripe: import("vxe-table").VxeTablePropTypes.Stripe;
+    headerAlign: import("vxe-table").VxeTablePropTypes.HeaderAlign;
+    footerAlign: import("vxe-table").VxeTablePropTypes.FooterAlign;
+    footerData: import("vxe-table").VxeTablePropTypes.FooterData;
+    footerMethod: import("vxe-table").VxeTablePropTypes.FooterMethod<any>;
+    rowClassName: import("vxe-table").VxeTablePropTypes.RowClassName<any>;
+    cellClassName: import("vxe-table").VxeTablePropTypes.CellClassName<any>;
+    headerRowClassName: import("vxe-table").VxeTablePropTypes.HeaderRowClassName<any>;
+    headerCellClassName: import("vxe-table").VxeTablePropTypes.HeaderCellClassName<any>;
+    footerRowClassName: import("vxe-table").VxeTablePropTypes.FooterRowClassName<any>;
+    footerCellClassName: import("vxe-table").VxeTablePropTypes.FooterCellClassName<any>;
+    cellStyle: import("vxe-table").VxeTablePropTypes.CellStyle<any>;
+    rowStyle: import("vxe-table").VxeTablePropTypes.RowStyle<any>;
+    headerCellStyle: import("vxe-table").VxeTablePropTypes.HeaderCellStyle<any>;
+    headerRowStyle: import("vxe-table").VxeTablePropTypes.HeaderRowStyle<any>;
+    footerRowStyle: import("vxe-table").VxeTablePropTypes.FooterRowStyle<any>;
+    footerCellStyle: import("vxe-table").VxeTablePropTypes.FooterCellStyle<any>;
+    mergeCells: import("vxe-table").VxeTablePropTypes.MergeCells<any>;
+    mergeFooterItems: import("vxe-table").VxeTablePropTypes.MergeFooterItems<any>;
+    spanMethod: import("vxe-table").VxeTablePropTypes.SpanMethod<any>;
+    footerSpanMethod: import("vxe-table").VxeTablePropTypes.FooterSpanMethod<any>;
+    keepSource: import("vxe-table").VxeTablePropTypes.KeepSource;
+    syncResize: import("vxe-table").VxeTablePropTypes.SyncResize;
+    columnConfig: import("vxe-table").VxeTablePropTypes.ColumnConfig<any>;
+    rowConfig: import("vxe-table").VxeTablePropTypes.RowConfig<any>;
+    cellConfig: import("vxe-table").VxeTablePropTypes.CellConfig<any>;
+    headerCellConfig: import("vxe-table").VxeTablePropTypes.HeaderCellConfig<any>;
+    footerCellConfig: import("vxe-table").VxeTablePropTypes.FooterCellConfig<any>;
+    rowGroupConfig: import("vxe-table").VxeTablePropTypes.RowGroupConfig<any>;
+    currentRowConfig: import("vxe-table").VxeTablePropTypes.CurrentRowConfig<any>;
+    currentColumnConfig: import("vxe-table").VxeTablePropTypes.CurrentColumnConfig<any>;
+    dragConfig: import("vxe-table").VxeTablePropTypes.DragConfig<any>;
+    rowDragConfig: import("vxe-table").VxeTablePropTypes.RowDragConfig<any>;
+    columnDragConfig: import("vxe-table").VxeTablePropTypes.ColumnDragConfig<any>;
+    customConfig: import("vxe-table").VxeTablePropTypes.CustomConfig<any>;
+    resizeConfig: import("vxe-table").VxeTablePropTypes.ResizeConfig;
+    resizableConfig: import("vxe-table").VxeTablePropTypes.ResizableConfig<any>;
+    seqConfig: import("vxe-table").VxeTablePropTypes.SeqConfig<any>;
+    sortConfig: import("vxe-table").VxeTablePropTypes.SortConfig<any>;
+    filterConfig: import("vxe-table").VxeTablePropTypes.FilterConfig<any>;
+    radioConfig: import("vxe-table").VxeTablePropTypes.RadioConfig<any>;
+    checkboxConfig: import("vxe-table").VxeTablePropTypes.CheckboxConfig<any>;
+    tooltipConfig: import("vxe-table").VxeTablePropTypes.TooltipConfig<any>;
+    exportConfig: import("vxe-table").VxeTablePropTypes.ExportConfig;
+    importConfig: import("vxe-table").VxeTablePropTypes.ImportConfig;
+    printConfig: import("vxe-table").VxeTablePropTypes.PrintConfig;
+    expandConfig: import("vxe-table").VxeTablePropTypes.ExpandConfig<any>;
+    treeConfig: import("vxe-table").VxeTablePropTypes.TreeConfig<any>;
+    menuConfig: import("vxe-table").VxeTablePropTypes.MenuConfig<any>;
+    mouseConfig: import("vxe-table").VxeTablePropTypes.MouseConfig;
+    areaConfig: import("vxe-table").VxeTablePropTypes.AreaConfig<any>;
+    fnrConfig: import("vxe-table").VxeTablePropTypes.FnrConfig<any>;
+    keyboardConfig: import("vxe-table").VxeTablePropTypes.KeyboardConfig<any>;
+    clipConfig: import("vxe-table").VxeTablePropTypes.ClipConfig<any>;
+    editConfig: import("vxe-table").VxeTablePropTypes.EditConfig<any>;
+    validConfig: import("vxe-table").VxeTablePropTypes.ValidConfig<any>;
+    editRules: import("vxe-table").VxeTablePropTypes.EditRules<any>;
+    emptyText: import("vxe-table").VxeTablePropTypes.EmptyText;
+    emptyRender: import("vxe-table").VxeTablePropTypes.EmptyRender;
+    loadingConfig: import("vxe-table").VxeTablePropTypes.LoadingConfig;
+    scrollX: import("vxe-table").VxeTablePropTypes.ScrollX;
+    scrollY: import("vxe-table").VxeTablePropTypes.ScrollY;
+    virtualXConfig: import("vxe-table").VxeTablePropTypes.VirtualXConfig;
+    virtualYConfig: import("vxe-table").VxeTablePropTypes.VirtualYConfig;
+    scrollbarConfig: import("vxe-table").VxeTablePropTypes.ScrollbarConfig;
+    params: import("vxe-table").VxeTablePropTypes.Params;
+    highlightCurrentRow: import("vxe-table").VxeTablePropTypes.HighlightCurrentRow;
+    highlightHoverRow: import("vxe-table").VxeTablePropTypes.HighlightHoverRow;
+    highlightCurrentColumn: import("vxe-table").VxeTablePropTypes.HighlightCurrentColumn;
+    highlightHoverColumn: import("vxe-table").VxeTablePropTypes.HighlightHoverColumn;
+    highlightCell: import("vxe-table").VxeTablePropTypes.HighlightCell;
+    columnKey: import("vxe-table").VxeTablePropTypes.ColumnKey;
+    rowKey: import("vxe-table").VxeTablePropTypes.RowKey;
+    rowId: import("vxe-table").VxeTablePropTypes.RowId;
+    animat: import("vxe-table").VxeTablePropTypes.Animat;
+    showIndexColumn: boolean;
+    onSortChange: import("vxe-table").VxeGridEvents.SortChange<any>;
+    onCheckboxAll: import("vxe-table").VxeGridEvents.CheckboxAll<any>;
+    onCheckboxChange: import("vxe-table").VxeGridEvents.CheckboxChange<any>;
+    sumFields: string[];
+    avgFields: string[];
+    onKeydownStart: import("vxe-table").VxeGridEvents.KeydownStart<any>;
+    onKeydownEnd: import("vxe-table").VxeGridEvents.KeydownEnd<any>;
+    onCurrentRowChange: import("vxe-table").VxeGridEvents.CurrentRowChange<any>;
+    onCurrentRowDisabled: import("vxe-table").VxeGridEvents.CurrentRowDisabled<any>;
+    onCurrentColumnChange: import("vxe-table").VxeGridEvents.CurrentColumnChange<any>;
+    onCurrentColumnDisabled: import("vxe-table").VxeGridEvents.CurrentColumnDisabled<any>;
+    onRadioChange: import("vxe-table").VxeGridEvents.RadioChange<any>;
+    onCheckboxRangeStart: import("vxe-table").VxeGridEvents.CheckboxRangeStart<any>;
+    onCheckboxRangeChange: import("vxe-table").VxeGridEvents.CheckboxRangeChange<any>;
+    onCheckboxRangeEnd: import("vxe-table").VxeGridEvents.CheckboxRangeEnd<any>;
+    onCellClick: import("vxe-table").VxeGridEvents.CellClick<any>;
+    onCellDblclick: import("vxe-table").VxeGridEvents.CellDblclick<any>;
+    onCellMenu: import("vxe-table").VxeGridEvents.CellMenu<any>;
+    onCellMouseenter: import("vxe-table").VxeGridEvents.CellMouseenter<any>;
+    onCellMouseleave: import("vxe-table").VxeGridEvents.CellMouseleave<any>;
+    onHeaderCellClick: import("vxe-table").VxeGridEvents.HeaderCellClick<any>;
+    onHeaderCellDblclick: import("vxe-table").VxeGridEvents.HeaderCellDblclick<any>;
+    onHeaderCellMenu: import("vxe-table").VxeGridEvents.HeaderCellMenu<any>;
+    onFooterCellClick: import("vxe-table").VxeGridEvents.FooterCellClick<any>;
+    onFooterCellDblclick: import("vxe-table").VxeGridEvents.FooterCellDblclick<any>;
+    onFooterCellMenu: import("vxe-table").VxeGridEvents.FooterCellMenu<any>;
+    onFilterChange: import("vxe-table").VxeGridEvents.FilterChange<any>;
+    onFilterVisible: import("vxe-table").VxeGridEvents.FilterVisible<any>;
+    onResizableChange: import("vxe-table").VxeGridEvents.ResizableChange<any>;
+    onToggleRowGroupExpand: import("vxe-table").VxeGridEvents.ToggleRowGroupExpand<any>;
+    onToggleRowExpand: import("vxe-table").VxeGridEvents.ToggleRowExpand<any>;
+    onToggleTreeExpand: import("vxe-table").VxeGridEvents.ToggleTreeExpand<any>;
+    onMenuClick: import("vxe-table").VxeGridEvents.MenuClick<any>;
+    onEditClosed: import("vxe-table").VxeGridEvents.EditClosed<any>;
+    onEditActivated: import("vxe-table").VxeGridEvents.EditActivated<any>;
+    onEditDisabled: import("vxe-table").VxeGridEvents.EditDisabled<any>;
+    onValidError: import("vxe-table").VxeGridEvents.ValidError<any>;
+    onScrollBoundary: import("vxe-table").VxeGridEvents.ScrollBoundary<any>;
+    onCustom: import("vxe-table").VxeGridEvents.Custom<any>;
+    onRowDragstart: import("vxe-table").VxeGridEvents.RowDragstart<any>;
+    onRowDragover: import("vxe-table").VxeGridEvents.RowDragover<any>;
+    onRowDragend: import("vxe-table").VxeGridEvents.RowDragend<any>;
+    onColumnDragstart: import("vxe-table").VxeGridEvents.ColumnDragstart<any>;
+    onColumnDragover: import("vxe-table").VxeGridEvents.ColumnDragover<any>;
+    onColumnDragend: import("vxe-table").VxeGridEvents.ColumnDragend<any>;
+    onEnterAppendRow: import("vxe-table").VxeGridEvents.EnterAppendRow<any>;
+    onProxyQuery: import("vxe-table").VxeGridEvents.ProxyQuery<any>;
+    onProxyDelete: import("vxe-table").VxeGridEvents.ProxyDelete<any>;
+    onProxySave: import("vxe-table").VxeGridEvents.ProxySave<any>;
+    onFormSubmit: import("vxe-table").VxeGridEvents.FormSubmit<any>;
+    onFormSubmitInvalid: import("vxe-table").VxeGridEvents.FormSubmitInvalid<any>;
+    onFormReset: import("vxe-table").VxeGridEvents.FormReset<any>;
+    onFormCollapse: import("vxe-table").VxeGridEvents.FormCollapse<any>;
+    onToolbarButtonClick: import("vxe-table").VxeGridEvents.ToolbarButtonClick<any>;
+    onToolbarToolClick: import("vxe-table").VxeGridEvents.ToolbarToolClick<any>;
+    onZoom: import("vxe-table").VxeGridEvents.Zoom<any>;
+    onEditActived: import("vxe-table").VxeGridEvents.EditActivated<any>;
+    onOpenFnr: import("vxe-table").VxeGridEvents.OpenFnr<any>;
+    onFnrChange: import("vxe-table").VxeGridEvents.FnrChange<any>;
+    onFnrFind: import("vxe-table").VxeGridEvents.FnrFind<any>;
+    onFnrFindAll: import("vxe-table").VxeGridEvents.FnrFindAll<any>;
+    onFnrReplace: import("vxe-table").VxeGridEvents.FnrReplace<any>;
+    onFnrReplaceAll: import("vxe-table").VxeGridEvents.FnrReplaceAll<any>;
+    onCellAreaCopy: import("vxe-table").VxeGridEvents.CellAreaCopy<any>;
+    onCellAreaCut: import("vxe-table").VxeGridEvents.CellAreaCut<any>;
+    onCellAreaPaste: import("vxe-table").VxeGridEvents.CellAreaPaste<any>;
+    onCellAreaMerge: import("vxe-table").VxeGridEvents.CellAreaMerge<any>;
+    onClearCellAreaMerge: import("vxe-table").VxeGridEvents.ClearCellAreaMerge<any>;
+    onClearCellAreaSelection: import("vxe-table").VxeGridEvents.ClearCellAreaSelection<any>;
+    onHeaderCellAreaSelection: import("vxe-table").VxeGridEvents.HeaderCellAreaSelection<any>;
+    onCellAreaSelectionInvalid: import("vxe-table").VxeGridEvents.CellAreaSelectionInvalid<any>;
+    onCellAreaSelectionStart: import("vxe-table").VxeGridEvents.CellAreaSelectionStart<any>;
+    onCellAreaSelectionDrag: import("vxe-table").VxeGridEvents.CellAreaSelectionDrag<any>;
+    onCellAreaSelectionEnd: import("vxe-table").VxeGridEvents.CellAreaSelectionEnd<any>;
+    onCellAreaExtensionStart: import("vxe-table").VxeGridEvents.CellAreaExtensionStart<any>;
+    onCellAreaExtensionDrag: import("vxe-table").VxeGridEvents.CellAreaExtensionDrag<any>;
+    onCellAreaExtensionEnd: import("vxe-table").VxeGridEvents.CellAreaExtensionEnd<any>;
+    onCellAreaSelectionAllStart: import("vxe-table").VxeGridEvents.CellAreaSelectionAllStart<any>;
+    onCellAreaSelectionAllEnd: import("vxe-table").VxeGridEvents.CellAreaSelectionAllEnd<any>;
+    onCellAreaArrowsStart: import("vxe-table").VxeGridEvents.CellAreaArrowsStart<any>;
+    onCellAreaArrowsEnd: import("vxe-table").VxeGridEvents.CellAreaArrowsEnd<any>;
+    onActiveCellChangeStart: import("vxe-table").VxeGridEvents.ActiveCellChangeStart<any>;
+    onActiveCellChangeEnd: import("vxe-table").VxeGridEvents.ActiveCellChangeEnd<any>;
+    toolbarFixed: boolean;
+    autoCreateKey: boolean;
+    showTableSetting: boolean;
+    tableSetting: import('./interface').TableSetting;
+    showSelection: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=BasicTable.vue.d.ts.map

package/dist/components/basic-table/BasicTable.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BasicTable.vue.d.ts","sourceRoot":"","sources":["../../../src/components/basic-table/BasicTable.vue"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,kBAAkB,EAAE,eAAe,EAAmB,eAAe,EAAE,MAAM,aAAa,CAAA;AAuIxG,iBAAS,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;MAuS+D,GAAG;wCAExC,GAAG;uCACH,GAAG;EAGnD;AAuBD,QAAA,MAAM,eAAe;;gBAzUuB,CAAC;;;;;;;;;;;;;;kHAcX,CAAC;;;;;oBAKqD,CAAC;;;;;;;;;;;;iCAKxF,CAAC;iCACE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAzGuE,GAAG;uBAEzE,CAAC,yCAAmB,GAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4EA+Z1B,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAAvG,wBAAwG;AACxG,KAAK,sBAAsB,CAAC,CAAC,IAAI,CAAC,SAAS,SAAS,GAAG,KAAK,GAAG,CAAC,CAAC;AACjE,KAAK,6BAA6B,CAAC,CAAC,IAAI;KAAG,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG,EAAE,SAAS,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG;QAAE,IAAI,EAAE,OAAO,KAAK,EAAE,QAAQ,CAAC,sBAAsB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;KAAE,GAAG;QAAE,IAAI,EAAE,OAAO,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAAC,QAAQ,EAAE,IAAI,CAAA;KAAE;CAAE,CAAC;AAC9M,KAAK,kBAAkB,CAAC,CAAC,EAAE,CAAC,IAAI;KAE1B,CAAC,IAAI,MAAM,IAAI,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,GAAG,CAAC,SAAS,MAAM,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG;QACxE,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC,CAAA;KACb,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CACT,CAAC;AACN,KAAK,cAAc,CAAC,CAAC,IAAI;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAAG,GAAG,EAAE,CAAC;AACxD,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IAAE,QAAO;QAClD,MAAM,EAAE,CAAC,CAAC;KACT,CAAA;CAAE,CAAC"}

package/dist/components/basic-table/constants.d.ts

@@ -0,0 +1,14 @@
+export declare const ROW_KEY = "_MAX_ROW_KEY";
+export declare const PAGE_SIZE_OPTIONS: number[];
+export declare const PAGE_SIZE = 10;
+export declare const FETCH_SETTING: {
+    pageField: string;
+    sizeField: string;
+    listField: string;
+    totalField: string;
+};
+export declare const DEFAULT_SIZE = "small";
+export declare const DEFAULT_ALIGN = "center";
+export declare const INDEX_COLUMN_FLAG = "INDEX";
+export declare const ACTION_COLUMN_FLAG = "ACTION";
+//# sourceMappingURL=constants.d.ts.map

package/dist/components/basic-table/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/components/basic-table/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,iBAAiB,CAAA;AAGrC,eAAO,MAAM,iBAAiB,UAAoB,CAAA;AAGlD,eAAO,MAAM,SAAS,KAAK,CAAA;AAG3B,eAAO,MAAM,aAAa;;;;;CASzB,CAAA;AAGD,eAAO,MAAM,YAAY,UAAU,CAAA;AAGnC,eAAO,MAAM,aAAa,WAAW,CAAA;AAErC,eAAO,MAAM,iBAAiB,UAAU,CAAA;AAExC,eAAO,MAAM,kBAAkB,WAAW,CAAA"}

package/dist/components/basic-table/context.d.ts

@@ -0,0 +1,7 @@
+import { InjectionKey } from 'vue';
+import { BasicTableContext } from './interface';
+
+export declare const basicTableKey: InjectionKey<BasicTableContext>;
+export declare const createBasicTableContext: (props: BasicTableContext) => void;
+export declare const useBasicTableContext: () => BasicTableContext;
+//# sourceMappingURL=context.d.ts.map

package/dist/components/basic-table/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../src/components/basic-table/context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,KAAK,CAAA;AAEvC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAEpD,eAAO,MAAM,aAAa,EAAE,YAAY,CAAC,iBAAiB,CAAyB,CAAA;AAEnF,eAAO,MAAM,uBAAuB,GAAI,OAAO,iBAAiB,SAE/D,CAAA;AAED,eAAO,MAAM,oBAAoB,QACC,iBACjC,CAAA"}

package/dist/components/basic-table/format.d.ts

@@ -0,0 +1,4 @@
+import { VxeTableFormatter } from './interface';
+
+export declare const vxeTableFormatter: VxeTableFormatter;
+//# sourceMappingURL=format.d.ts.map

package/dist/components/basic-table/format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../../src/components/basic-table/format.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAEpD,eAAO,MAAM,iBAAiB,EAAE,iBAqC/B,CAAA"}

package/dist/components/basic-table/helper.d.ts

@@ -0,0 +1,9 @@
+import { VxeGlobalConfig } from 'vxe-pc-ui';
+import { BasicTableProps, VxeTableFormatter } from './interface';
+
+export declare function parseRowKey(rowKey: BasicTableProps['rKey'], record: Record<string, any>, autoCreateKey?: boolean): number | string;
+export declare function parseRowKeyValue(rowKey: BasicTableProps['rKey'], record: Record<string, any>, autoCreateKey?: boolean): number | string;
+export declare function setVxeTableTheme(name?: string): void;
+export declare function setVxeUIConfig(config?: VxeGlobalConfig): void;
+export declare function setVxeUIFormat(format: VxeTableFormatter): void;
+//# sourceMappingURL=helper.d.ts.map

package/dist/components/basic-table/helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helper.d.ts","sourceRoot":"","sources":["../../../src/components/basic-table/helper.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAA;AAEhD,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAIrE,wBAAgB,WAAW,CAAC,MAAM,EAAE,eAAe,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,aAAa,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,CAUlI;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,eAAe,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,aAAa,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,CAEvI;AAED,wBAAgB,gBAAgB,CAAC,IAAI,CAAC,EAAE,MAAM,QAQ7C;AAED,wBAAgB,cAAc,CAAC,MAAM,GAAE,eAAoB,QAG1D;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,iBAAiB,QAEvD"}

package/dist/components/basic-table/hooks/index.d.ts

@@ -0,0 +1,10 @@
+export * from './use-columns';
+export * from './use-data-source';
+export * from './use-loading';
+export * from './use-pagination';
+export * from './use-row-selection';
+export * from './use-table-config';
+export * from './use-table-context';
+export * from './use-table-footer';
+export * from './use-table-form';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/basic-table/hooks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/components/basic-table/hooks/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAA;AAC7B,cAAc,mBAAmB,CAAA;AACjC,cAAc,eAAe,CAAA;AAC7B,cAAc,kBAAkB,CAAA;AAChC,cAAc,qBAAqB,CAAA;AACnC,cAAc,oBAAoB,CAAA;AAClC,cAAc,qBAAqB,CAAA;AACnC,cAAc,oBAAoB,CAAA;AAClC,cAAc,kBAAkB,CAAA"}

package/dist/components/basic-table/hooks/use-columns.d.ts

@@ -0,0 +1,13 @@
+import { ComputedRef, Ref } from 'vue';
+import { BasicColumn, BasicPagerProps, BasicTableProps, GetColumnsParams } from '../interface';
+
+export declare function useColumns(propsRef: ComputedRef<BasicTableProps>, getPaginationRef: Ref<boolean | BasicPagerProps>): {
+    getColumnsRef: ComputedRef<BasicColumn[]>;
+    getCacheColumns: () => import("vxe-pc-ui/types/components/grid").VxeGridPropTypes.Columns<any> & BasicColumn[];
+    setColumns: (columnList: Array<Partial<BasicColumn>> | Array<string | string[]>) => void;
+    getColumns: (opt?: GetColumnsParams) => BasicColumn[];
+    getViewColumns: ComputedRef<BasicColumn[]>;
+    setCacheColumnsByField: (field: string | undefined, value: Partial<BasicColumn>) => void;
+    setCacheColumns: (columns: BasicColumn[]) => void;
+};
+//# sourceMappingURL=use-columns.d.ts.map

package/dist/components/basic-table/hooks/use-columns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-columns.d.ts","sourceRoot":"","sources":["../../../../src/components/basic-table/hooks/use-columns.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAI3C,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAoEnG,wBAAgB,UAAU,CAAC,QAAQ,EAAE,WAAW,CAAC,eAAe,CAAC,EAAE,gBAAgB,EAAE,GAAG,CAAC,OAAO,GAAG,eAAe,CAAC;;;6BA2DjF,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,GAAG,KAAK,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC;uBAkC5D,gBAAgB;;oCAjDH,MAAM,GAAG,SAAS,SAAS,OAAO,CAAC,WAAW,CAAC;+BAkEpD,WAAW,EAAE;EAchD"}

package/dist/components/basic-table/hooks/use-data-source.d.ts

@@ -0,0 +1,50 @@
+import { ComputedRef, Ref } from 'vue';
+import { KeyValueType, Recordable, ReturnEmitType } from '@maxax/types';
+import { BasicPagerProps, BasicTableProps, BasicTableRowKey, FetchParams, TableSortFilter, VxePagerEvents } from '../interface';
+
+interface UseDataSourceActionType {
+    getPaginationInfo: Ref<boolean | BasicPagerProps>;
+    setPagination: (info: Partial<BasicPagerProps>) => void;
+    setLoading: (loading: boolean) => void;
+    clearSelectedRowKeys: () => void;
+    setSelection: () => void;
+    tableData: Ref<Recordable[]>;
+    emit: ReturnEmitType;
+}
+export declare function useDataSource(propsRef: ComputedRef<BasicTableProps>, { tableData, getPaginationInfo, setPagination, setSelection, setLoading, emit }: UseDataSourceActionType): {
+    getRowKey: ComputedRef<string | import('../interface').GetRowKey | undefined>;
+    getRowConfigRef: ComputedRef<{
+        rowConfig: {
+            keyField: string | import('../interface').GetRowKey | undefined;
+            useKey?: boolean;
+            isCurrent?: boolean;
+            currentMethod?: ((params: {
+                row: any;
+            }) => boolean) | undefined;
+            isHover?: boolean;
+            resizable?: boolean;
+            height?: number;
+            drag?: boolean;
+        };
+    }>;
+    searchInfoRef: Ref<Recordable<any>, Recordable<any>>;
+    getAutoCreateKey: ComputedRef<boolean | undefined>;
+    getDataSourceRef: Ref<Recordable<any>[], Recordable<any>[]>;
+    getSortRef: ComputedRef<TableSortFilter<import("vxe-pc-ui/types/components/table").VxeTablePropTypes.Row> | null>;
+    fetch: (opt?: FetchParams) => Promise<Recordable<any>[] | undefined>;
+    reload: (opt?: FetchParams) => Promise<Recordable<any>[] | undefined>;
+    onPageChange: VxePagerEvents.PageChange;
+    getDataSource: <T = Recordable<any>>() => T[];
+    getRawDataSource: <T = Recordable<any>>() => T;
+    getSearchInfo: <T = Recordable<any>>() => T;
+    setTableData: <T = Recordable<any>>(values: T[]) => void;
+    updateTableData: (index: number, key: BasicTableRowKey, value: any) => Promise<Recordable<any>>;
+    updateTableDataRecord: (keyValue: BasicTableRowKey, record: Recordable) => Recordable | undefined;
+    deleteTableDataRecord: (keyValues: BasicTableRowKey | BasicTableRowKey[]) => void;
+    insertTableDataRecord: (record: Recordable | Recordable[], index?: number) => Recordable[] | undefined;
+    findTableDataRecord: (keyValue: BasicTableRowKey) => Record<string, any> | undefined;
+    getTableRowKey: () => string | import('../interface').GetRowKey | undefined;
+    mergeTableDataRecord: (records: Recordable[], key?: KeyValueType) => void;
+};
+export {};
+//# sourceMappingURL=use-data-source.d.ts.map

package/dist/components/basic-table/hooks/use-data-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-data-source.d.ts","sourceRoot":"","sources":["../../../../src/components/basic-table/hooks/use-data-source.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAG3C,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAK5E,OAAO,KAAK,EAAE,eAAe,EAAE,eAAe,EAAE,gBAAgB,EAAE,WAAW,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAEpI,UAAU,uBAAuB;IAC/B,iBAAiB,EAAE,GAAG,CAAC,OAAO,GAAG,eAAe,CAAC,CAAA;IACjD,aAAa,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,eAAe,CAAC,KAAK,IAAI,CAAA;IACvD,UAAU,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAA;IACtC,oBAAoB,EAAE,MAAM,IAAI,CAAA;IAChC,YAAY,EAAE,MAAM,IAAI,CAAA;IACxB,SAAS,EAAE,GAAG,CAAC,UAAU,EAAE,CAAC,CAAA;IAC5B,IAAI,EAAE,cAAc,CAAA;CACrB;AAYD,wBAAgB,aAAa,CAAC,QAAQ,EAAE,WAAW,CAAC,eAAe,CAAC,EAAE,EAAE,SAAS,EAAE,iBAAiB,EAAE,aAAa,EAAE,YAAY,EAAE,UAAU,EAAE,IAAI,EAAE,EAAE,uBAAuB;;;;;;;;;;;;;;;;;;;;kBAkMjJ,WAAW;mBApBV,WAAW;;oBARhB,CAAC,yBACW,CAAC,EAAE;uBAGZ,CAAC,yBACQ,CAAC;oBAOb,CAAC,yBACQ,CAAC;mBAjBX,CAAC,4BAAuB,CAAC,EAAE;6BApCX,MAAM,OAAO,gBAAgB,SAAS,GAAG;sCAQtC,gBAAgB,UAAU,UAAU,KAAG,UAAU,GAAG,SAAS;uCAW5D,gBAAgB,GAAG,gBAAgB,EAAE;oCAUxC,UAAU,GAAG,UAAU,EAAE,UAAU,MAAM,KAAG,UAAU,EAAE,GAAG,SAAS;oCAjDpE,gBAAgB;;oCAkFhB,UAAU,EAAE,QAAO,YAAY;EA6JvE"}

package/dist/components/basic-table/hooks/use-loading.d.ts

@@ -0,0 +1,8 @@
+import { ComputedRef } from 'vue';
+import { BasicTableProps } from '../interface';
+
+export declare function useLoading(props: ComputedRef<BasicTableProps>): {
+    getLoading: ComputedRef<boolean | undefined>;
+    setLoading: (loading: boolean) => void;
+};
+//# sourceMappingURL=use-loading.d.ts.map

package/dist/components/basic-table/hooks/use-loading.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-loading.d.ts","sourceRoot":"","sources":["../../../../src/components/basic-table/hooks/use-loading.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,KAAK,CAAA;AAEtC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAEnD,wBAAgB,UAAU,CAAC,KAAK,EAAE,WAAW,CAAC,eAAe,CAAC;;0BAY/B,OAAO;EAKrC"}

package/dist/components/basic-table/hooks/use-pagination.d.ts

@@ -0,0 +1,92 @@
+import { ComputedRef } from 'vue';
+import { BasicPagerProps, BasicTableEmitType, BasicTableProps } from '../interface';
+
+export declare function usePagination(propsRef: ComputedRef<BasicTableProps>, _emit: BasicTableEmitType): {
+    getPagination: () => import('vxe-pc-ui/types/components/pager').VxePagerProps | {
+        size?: import("vxe-pc-ui").VxePagerPropTypes.Size | undefined;
+        layouts?: ("Home" | "End" | "PrevJump" | "PrevPage" | "Number" | "JumpNumber" | "NextPage" | "NextJump" | "Sizes" | "Jump" | "FullJump" | "PageCount" | "Total")[] | undefined;
+        currentPage?: import("vxe-pc-ui").VxePagerPropTypes.CurrentPage | undefined;
+        loading?: import("vxe-pc-ui").VxePagerPropTypes.Loading | undefined;
+        pageSize?: import("vxe-pc-ui").VxePagerPropTypes.PageSize | undefined;
+        total?: import("vxe-pc-ui").VxePagerPropTypes.Total | undefined;
+        pagerCount?: import("vxe-pc-ui").VxePagerPropTypes.PagerCount | undefined;
+        pageSizes?: (number | {
+            label?: number | string | undefined;
+            value?: number | string | undefined;
+        })[] | undefined;
+        align?: import("vxe-pc-ui").VxePagerPropTypes.Align | undefined;
+        border?: import("vxe-pc-ui").VxePagerPropTypes.Border | undefined;
+        background?: import("vxe-pc-ui").VxePagerPropTypes.Background | undefined;
+        perfect?: import("vxe-pc-ui").VxePagerPropTypes.Perfect | undefined;
+        autoHidden?: import("vxe-pc-ui").VxePagerPropTypes.AutoHidden | undefined;
+        transfer?: import("vxe-pc-ui").VxePagerPropTypes.Transfer | undefined;
+        className?: import("vxe-pc-ui").VxePagerPropTypes.ClassName | undefined;
+        pageSizePlacement?: import("vxe-pc-ui").VxePagerPropTypes.PageSizePlacement | undefined;
+        iconPrevPage?: import("vxe-pc-ui").VxePagerPropTypes.IconPrevPage | undefined;
+        iconJumpPrev?: import("vxe-pc-ui").VxePagerPropTypes.IconJumpPrev | undefined;
+        iconJumpNext?: import("vxe-pc-ui").VxePagerPropTypes.IconJumpNext | undefined;
+        iconNextPage?: import("vxe-pc-ui").VxePagerPropTypes.IconNextPage | undefined;
+        iconJumpMore?: import("vxe-pc-ui").VxePagerPropTypes.IconJumpMore | undefined;
+        iconHomePage?: import("vxe-pc-ui").VxePagerPropTypes.IconHomePage | undefined;
+        iconEndPage?: import("vxe-pc-ui").VxePagerPropTypes.IconEndPage | undefined;
+    };
+    getPaginationInfo: import('vue').Ref<{
+        size?: import("vxe-pc-ui").VxePagerPropTypes.Size | undefined;
+        layouts?: ("Home" | "End" | "PrevJump" | "PrevPage" | "Number" | "JumpNumber" | "NextPage" | "NextJump" | "Sizes" | "Jump" | "FullJump" | "PageCount" | "Total")[] | undefined;
+        currentPage?: import("vxe-pc-ui").VxePagerPropTypes.CurrentPage | undefined;
+        loading?: import("vxe-pc-ui").VxePagerPropTypes.Loading | undefined;
+        pageSize?: import("vxe-pc-ui").VxePagerPropTypes.PageSize | undefined;
+        total?: import("vxe-pc-ui").VxePagerPropTypes.Total | undefined;
+        pagerCount?: import("vxe-pc-ui").VxePagerPropTypes.PagerCount | undefined;
+        pageSizes?: (number | {
+            label?: number | string | undefined;
+            value?: number | string | undefined;
+        })[] | undefined;
+        align?: import("vxe-pc-ui").VxePagerPropTypes.Align | undefined;
+        border?: import("vxe-pc-ui").VxePagerPropTypes.Border | undefined;
+        background?: import("vxe-pc-ui").VxePagerPropTypes.Background | undefined;
+        perfect?: import("vxe-pc-ui").VxePagerPropTypes.Perfect | undefined;
+        autoHidden?: import("vxe-pc-ui").VxePagerPropTypes.AutoHidden | undefined;
+        transfer?: import("vxe-pc-ui").VxePagerPropTypes.Transfer | undefined;
+        className?: import("vxe-pc-ui").VxePagerPropTypes.ClassName | undefined;
+        pageSizePlacement?: import("vxe-pc-ui").VxePagerPropTypes.PageSizePlacement | undefined;
+        iconPrevPage?: import("vxe-pc-ui").VxePagerPropTypes.IconPrevPage | undefined;
+        iconJumpPrev?: import("vxe-pc-ui").VxePagerPropTypes.IconJumpPrev | undefined;
+        iconJumpNext?: import("vxe-pc-ui").VxePagerPropTypes.IconJumpNext | undefined;
+        iconNextPage?: import("vxe-pc-ui").VxePagerPropTypes.IconNextPage | undefined;
+        iconJumpMore?: import("vxe-pc-ui").VxePagerPropTypes.IconJumpMore | undefined;
+        iconHomePage?: import("vxe-pc-ui").VxePagerPropTypes.IconHomePage | undefined;
+        iconEndPage?: import("vxe-pc-ui").VxePagerPropTypes.IconEndPage | undefined;
+    }, import('vxe-pc-ui/types/components/pager').VxePagerProps | {
+        size?: import("vxe-pc-ui").VxePagerPropTypes.Size | undefined;
+        layouts?: ("Home" | "End" | "PrevJump" | "PrevPage" | "Number" | "JumpNumber" | "NextPage" | "NextJump" | "Sizes" | "Jump" | "FullJump" | "PageCount" | "Total")[] | undefined;
+        currentPage?: import("vxe-pc-ui").VxePagerPropTypes.CurrentPage | undefined;
+        loading?: import("vxe-pc-ui").VxePagerPropTypes.Loading | undefined;
+        pageSize?: import("vxe-pc-ui").VxePagerPropTypes.PageSize | undefined;
+        total?: import("vxe-pc-ui").VxePagerPropTypes.Total | undefined;
+        pagerCount?: import("vxe-pc-ui").VxePagerPropTypes.PagerCount | undefined;
+        pageSizes?: (number | {
+            label?: number | string | undefined;
+            value?: number | string | undefined;
+        })[] | undefined;
+        align?: import("vxe-pc-ui").VxePagerPropTypes.Align | undefined;
+        border?: import("vxe-pc-ui").VxePagerPropTypes.Border | undefined;
+        background?: import("vxe-pc-ui").VxePagerPropTypes.Background | undefined;
+        perfect?: import("vxe-pc-ui").VxePagerPropTypes.Perfect | undefined;
+        autoHidden?: import("vxe-pc-ui").VxePagerPropTypes.AutoHidden | undefined;
+        transfer?: import("vxe-pc-ui").VxePagerPropTypes.Transfer | undefined;
+        className?: import("vxe-pc-ui").VxePagerPropTypes.ClassName | undefined;
+        pageSizePlacement?: import("vxe-pc-ui").VxePagerPropTypes.PageSizePlacement | undefined;
+        iconPrevPage?: import("vxe-pc-ui").VxePagerPropTypes.IconPrevPage | undefined;
+        iconJumpPrev?: import("vxe-pc-ui").VxePagerPropTypes.IconJumpPrev | undefined;
+        iconJumpNext?: import("vxe-pc-ui").VxePagerPropTypes.IconJumpNext | undefined;
+        iconNextPage?: import("vxe-pc-ui").VxePagerPropTypes.IconNextPage | undefined;
+        iconJumpMore?: import("vxe-pc-ui").VxePagerPropTypes.IconJumpMore | undefined;
+        iconHomePage?: import("vxe-pc-ui").VxePagerPropTypes.IconHomePage | undefined;
+        iconEndPage?: import("vxe-pc-ui").VxePagerPropTypes.IconEndPage | undefined;
+    }>;
+    setShowPagination: (flag: boolean) => Promise<void>;
+    getShowPagination: () => boolean;
+    setPagination: (info: Partial<BasicPagerProps>) => void;
+};
+//# sourceMappingURL=use-pagination.d.ts.map

package/dist/components/basic-table/hooks/use-pagination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-pagination.d.ts","sourceRoot":"","sources":["../../../../src/components/basic-table/hooks/use-pagination.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,KAAK,CAAA;AAItC,OAAO,KAAK,EAAE,eAAe,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAExF,wBAAgB,aAAa,CAAC,QAAQ,EAAE,WAAW,CAAC,eAAe,CAAC,EAAE,KAAK,EAAE,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BA2CtD,OAAO;;0BAhBjB,OAAO,CAAC,eAAe,CAAC;EAqBtD"}

package/dist/components/basic-table/hooks/use-row-selection.d.ts

@@ -0,0 +1,20 @@
+import { ComputedRef, Ref } from 'vue';
+import { Recordable } from '@maxax/types';
+import { BasicTableEmitType, BasicTableProps, GetSelectionReturn, Key, TableRowSelection, VxeGridInstance } from '../interface';
+
+export declare function useRowSelection(propsRef: ComputedRef<BasicTableProps>, tableData: Ref<Recordable[]>, emit: BasicTableEmitType, tableElRef: Ref<VxeGridInstance>): {
+    getSelection: () => GetSelectionReturn;
+    setSelection: () => Promise<void>;
+    clearSelection: () => Promise<void>;
+    getRowSelection: () => TableRowSelection<import("vxe-pc-ui/types/components/table").VxeTablePropTypes.Row>;
+    selectedRowRef: Ref<Recordable<any>[], Recordable<any>[]>;
+    selectedRowKeysRef: Ref<Key[], Key[]>;
+    getRowSelectionRef: ComputedRef<TableRowSelection<import("vxe-pc-ui/types/components/table").VxeTablePropTypes.Row> | null>;
+    getSelectRows: <T = Recordable<any>>() => T[];
+    getSelectRowKeys: () => Key[];
+    setSelectedRowKeys: (keyValues?: Key[]) => void;
+    clearSelectedRowKeys: () => void;
+    deleteSelectRowByKey: (key: Key) => void;
+    setSelectedRows: (rows: Recordable[]) => void;
+};
+//# sourceMappingURL=use-row-selection.d.ts.map

package/dist/components/basic-table/hooks/use-row-selection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-row-selection.d.ts","sourceRoot":"","sources":["../../../../src/components/basic-table/hooks/use-row-selection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAE3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAK9C,OAAO,KAAK,EAAE,kBAAkB,EAAE,eAAe,EAAE,kBAAkB,EAAE,GAAG,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAEpI,wBAAgB,eAAe,CAAC,QAAQ,EAAE,WAAW,CAAC,eAAe,CAAC,EAAE,SAAS,EAAE,GAAG,CAAC,UAAU,EAAE,CAAC,EAAE,IAAI,EAAE,kBAAkB,EAAE,UAAU,EAAE,GAAG,CAAC,eAAe,CAAC;wBA8DrI,kBAAkB;;;;;;;oBAuHpB,CAAC,yBACqB,CAAC,EAAE;;qCApCR,GAAG,EAAE;;gCAqBV,GAAG;4BAXP,UAAU,EAAE;EAgD5C"}