@maxax/ui 1.1.22 → 1.1.23

package/dist/component.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"component.d.ts","sourceRoot":"","sources":["../src/component.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,KAAK,CAAA;AAqDjC,eAAO,MAAM,UAAU,UA+DV,CAAA;AAEb,eAAe,UAAU,CAAA"}
+{"version":3,"file":"component.d.ts","sourceRoot":"","sources":["../src/component.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,KAAK,CAAA;AAsDjC,eAAO,MAAM,UAAU,UAgEV,CAAA;AAEb,eAAe,UAAU,CAAA"}

package/dist/components/basic-button-import-preview/BasicButtonImportPreview.vue.d.ts

@@ -0,0 +1,541 @@
+import { Recordable } from '@maxax/types';
+import { BasicButtonImportPreviewProps } from './interface';
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<BasicButtonImportPreviewProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    import: (_data: {
+        data: any;
+        checked: boolean;
+        file: Blob;
+    }) => any;
+    preview: (_data: {
+        data: any;
+        checked: boolean;
+        file: Blob;
+        records: any[];
+    }) => any;
+}, string, import('vue').PublicProps, Readonly<BasicButtonImportPreviewProps> & Readonly<{
+    onImport?: ((_data: {
+        data: any;
+        checked: boolean;
+        file: Blob;
+    }) => any) | undefined;
+    onPreview?: ((_data: {
+        data: any;
+        checked: boolean;
+        file: Blob;
+        records: any[];
+    }) => any) | undefined;
+}>, {
+    listField: string;
+    showTplButton: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    uploadModalRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./interface').BasicButtonImportUploadModalProps> & Readonly<{
+        onConfirm?: ((_data: {
+            file: Blob;
+            checked: boolean;
+        }) => any) | undefined;
+        onDownloadTemplate?: (() => any) | undefined;
+    }>, {
+        show: (context: import('../../composable').BasicDrawerModalContext) => void;
+        hide: () => void;
+        showLoading: () => void;
+        hideLoading: () => void;
+        loading: import('vue').Ref<boolean, boolean>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        confirm: (_data: {
+            file: Blob;
+            checked: boolean;
+        }) => any;
+        downloadTemplate: () => any;
+    }, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('./interface').BasicButtonImportUploadModalProps> & Readonly<{
+        onConfirm?: ((_data: {
+            file: Blob;
+            checked: boolean;
+        }) => any) | undefined;
+        onDownloadTemplate?: (() => any) | undefined;
+    }>, {
+        show: (context: import('../../composable').BasicDrawerModalContext) => void;
+        hide: () => void;
+        showLoading: () => void;
+        hideLoading: () => void;
+        loading: import('vue').Ref<boolean, boolean>;
+    }, {}, {}, {}, {}> | null;
+    previewModalRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./interface').BasicButtonImportPreviewModalProps> & Readonly<{
+        onCancel?: (() => any) | undefined;
+        onConfirm?: ((_data: {
+            data: any[];
+            records: any[];
+        }) => any) | undefined;
+    }>, {
+        show: (context: import('../../composable').BasicDrawerModalContext) => void;
+        hide: () => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        cancel: () => any;
+        confirm: (_data: {
+            data: any[];
+            records: any[];
+        }) => any;
+    }, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        basicTableRef: ({
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly layouts?: import("vxe-table").VxeGridPropTypes.Layouts | undefined;
+                readonly columns: import("vxe-table").VxeGridPropTypes.Columns<any> & import('..').BasicColumn[];
+                readonly pagerConfig?: import("vxe-table").VxeGridPropTypes.PagerConfig | undefined;
+                readonly proxyConfig?: import("vxe-table").VxeGridPropTypes.ProxyConfig<any> | undefined;
+                readonly toolbarConfig?: import("vxe-table").VxeGridPropTypes.ToolbarConfig | undefined;
+                readonly formConfig?: import("vxe-table").VxeGridPropTypes.FormConfig | undefined;
+                readonly zoomConfig?: import("vxe-table").VxeGridPropTypes.ZoomConfig | undefined;
+                readonly size?: import('vxe-pc-ui').VxeComponentSizeType | undefined;
+                readonly id?: import("vxe-table").VxeTablePropTypes.ID<any> | undefined;
+                readonly data?: import("vxe-table").VxeTablePropTypes.Data<any> | undefined;
+                readonly height?: import("vxe-table").VxeTablePropTypes.Height | undefined;
+                readonly minHeight?: import("vxe-table").VxeTablePropTypes.MinHeight | undefined;
+                readonly maxHeight?: import("vxe-table").VxeTablePropTypes.MaxHeight | undefined;
+                readonly stripe?: boolean | undefined;
+                readonly padding?: boolean | undefined;
+                readonly round?: boolean | undefined;
+                readonly border?: import("vxe-table").VxeTablePropTypes.Border | undefined;
+                readonly loading?: boolean | undefined;
+                readonly align?: import('vxe-pc-ui').VxeComponentAlignType | undefined;
+                readonly headerAlign?: import('vxe-pc-ui').VxeComponentAlignType | undefined;
+                readonly footerAlign?: import('vxe-pc-ui').VxeComponentAlignType | undefined;
+                readonly showHeader?: boolean | undefined;
+                readonly showFooter?: boolean | undefined;
+                readonly footerData?: import("vxe-table").VxeTablePropTypes.FooterData | undefined;
+                readonly footerMethod?: import("vxe-table").VxeTablePropTypes.FooterMethod<any> | undefined;
+                readonly rowClassName?: import("vxe-table").VxeTablePropTypes.RowClassName<any> | undefined;
+                readonly cellClassName?: import("vxe-table").VxeTablePropTypes.CellClassName<any> | undefined;
+                readonly headerRowClassName?: import("vxe-table").VxeTablePropTypes.HeaderRowClassName<any> | undefined;
+                readonly headerCellClassName?: import("vxe-table").VxeTablePropTypes.HeaderCellClassName<any> | undefined;
+                readonly footerRowClassName?: import("vxe-table").VxeTablePropTypes.FooterRowClassName<any> | undefined;
+                readonly footerCellClassName?: import("vxe-table").VxeTablePropTypes.FooterCellClassName<any> | undefined;
+                readonly cellStyle?: import("vxe-table").VxeTablePropTypes.CellStyle<any> | undefined;
+                readonly rowStyle?: import("vxe-table").VxeTablePropTypes.RowStyle<any> | undefined;
+                readonly headerCellStyle?: import("vxe-table").VxeTablePropTypes.HeaderCellStyle<any> | undefined;
+                readonly headerRowStyle?: import("vxe-table").VxeTablePropTypes.HeaderRowStyle<any> | undefined;
+                readonly footerRowStyle?: import("vxe-table").VxeTablePropTypes.FooterRowStyle<any> | undefined;
+                readonly footerCellStyle?: import("vxe-table").VxeTablePropTypes.FooterCellStyle<any> | undefined;
+                readonly showCustomHeader?: boolean | undefined;
+                readonly mergeHeaderCells?: import("vxe-table").VxeTablePropTypes.MergeHeaderCells | undefined;
+                readonly mergeCells?: import("vxe-table").VxeTablePropTypes.MergeCells<any> | undefined;
+                readonly mergeFooterCells?: import("vxe-table").VxeTablePropTypes.MergeFooterCells<any> | undefined;
+                readonly mergeFooterItems?: import("vxe-table").VxeTablePropTypes.MergeFooterItems<any> | undefined;
+                readonly spanMethod?: import("vxe-table").VxeTablePropTypes.SpanMethod<any> | undefined;
+                readonly footerSpanMethod?: import("vxe-table").VxeTablePropTypes.FooterSpanMethod<any> | undefined;
+                readonly showOverflow?: import("vxe-table").VxeTablePropTypes.ShowOverflow | undefined;
+                readonly showHeaderOverflow?: import("vxe-table").VxeTablePropTypes.ShowOverflow | undefined;
+                readonly showFooterOverflow?: import("vxe-table").VxeTablePropTypes.ShowOverflow | undefined;
+                readonly keepSource?: boolean | undefined;
+                readonly autoResize?: boolean | undefined;
+                readonly syncResize?: import("vxe-table").VxeTablePropTypes.SyncResize | undefined;
+                readonly columnConfig?: import("vxe-table").VxeTablePropTypes.ColumnConfig<any> | undefined;
+                readonly rowConfig?: import("vxe-table").VxeTablePropTypes.RowConfig<any> | undefined;
+                readonly cellConfig?: import("vxe-table").VxeTablePropTypes.CellConfig<any> | undefined;
+                readonly headerCellConfig?: import("vxe-table").VxeTablePropTypes.HeaderCellConfig<any> | undefined;
+                readonly footerCellConfig?: import("vxe-table").VxeTablePropTypes.FooterCellConfig<any> | undefined;
+                readonly aggregateConfig?: import("vxe-table").VxeTablePropTypes.AggregateConfig<any> | undefined;
+                readonly rowGroupConfig?: import("vxe-table").VxeTablePropTypes.RowGroupConfig<any> | undefined;
+                readonly currentRowConfig?: import("vxe-table").VxeTablePropTypes.CurrentRowConfig<any> | undefined;
+                readonly currentColumnConfig?: import("vxe-table").VxeTablePropTypes.CurrentColumnConfig<any> | undefined;
+                readonly dragConfig?: import("vxe-table").VxeTablePropTypes.DragConfig<any> | undefined;
+                readonly rowDragConfig?: import("vxe-table").VxeTablePropTypes.RowDragConfig<any> | undefined;
+                readonly columnDragConfig?: import("vxe-table").VxeTablePropTypes.ColumnDragConfig<any> | undefined;
+                readonly customConfig?: import("vxe-table").VxeTablePropTypes.CustomConfig<any> | undefined;
+                readonly resizeConfig?: import("vxe-table").VxeTablePropTypes.ResizeConfig | undefined;
+                readonly resizableConfig?: import("vxe-table").VxeTablePropTypes.ResizableConfig<any> | undefined;
+                readonly seqConfig?: import("vxe-table").VxeTablePropTypes.SeqConfig<any> | undefined;
+                readonly sortConfig?: import("vxe-table").VxeTablePropTypes.SortConfig<any> | undefined;
+                readonly filterConfig?: import("vxe-table").VxeTablePropTypes.FilterConfig<any> | undefined;
+                readonly floatingFilterConfig?: import("vxe-table").VxeTablePropTypes.FloatingFilterConfig<any> | undefined;
+                readonly radioConfig?: import("vxe-table").VxeTablePropTypes.RadioConfig<any> | undefined;
+                readonly checkboxConfig?: import("vxe-table").VxeTablePropTypes.CheckboxConfig<any> | undefined;
+                readonly headerTooltipConfig?: import("vxe-table").VxeTablePropTypes.HeaderTooltipConfig<any> | undefined;
+                readonly tooltipConfig?: import("vxe-table").VxeTablePropTypes.TooltipConfig<any> | undefined;
+                readonly footerTooltipConfig?: import("vxe-table").VxeTablePropTypes.FooterTooltipConfig<any> | undefined;
+                readonly exportConfig?: import("vxe-table").VxeTablePropTypes.ExportConfig | undefined;
+                readonly importConfig?: import("vxe-table").VxeTablePropTypes.ImportConfig | undefined;
+                readonly printConfig?: import("vxe-table").VxeTablePropTypes.PrintConfig | undefined;
+                readonly expandConfig?: import("vxe-table").VxeTablePropTypes.ExpandConfig<any> | undefined;
+                readonly treeConfig?: import("vxe-table").VxeTablePropTypes.TreeConfig<any> | undefined;
+                readonly menuConfig?: import("vxe-table").VxeTablePropTypes.MenuConfig<any> | undefined;
+                readonly mouseConfig?: import("vxe-table").VxeTablePropTypes.MouseConfig | undefined;
+                readonly areaConfig?: import("vxe-table").VxeTablePropTypes.AreaConfig<any> | undefined;
+                readonly fnrConfig?: import("vxe-table").VxeTablePropTypes.FnrConfig<any> | undefined;
+                readonly keyboardConfig?: import("vxe-table").VxeTablePropTypes.KeyboardConfig<any> | undefined;
+                readonly clipConfig?: import("vxe-table").VxeTablePropTypes.ClipConfig<any> | undefined;
+                readonly editConfig?: import("vxe-table").VxeTablePropTypes.EditConfig<any> | undefined;
+                readonly validConfig?: import("vxe-table").VxeTablePropTypes.ValidConfig<any> | undefined;
+                readonly editRules?: import("vxe-table").VxeTablePropTypes.EditRules<any> | undefined;
+                readonly undoHistoryConfig?: import("vxe-table").VxeTablePropTypes.UndoHistoryConfig | undefined;
+                readonly emptyText?: string | undefined;
+                readonly emptyRender?: import("vxe-table").VxeTablePropTypes.EmptyRender | undefined;
+                readonly loadingConfig?: import("vxe-table").VxeTablePropTypes.LoadingConfig | undefined;
+                readonly scrollX?: import("vxe-table").VxeTablePropTypes.ScrollX | undefined;
+                readonly scrollY?: import("vxe-table").VxeTablePropTypes.ScrollY | undefined;
+                readonly virtualXConfig?: import("vxe-table").VxeTablePropTypes.VirtualXConfig | undefined;
+                readonly virtualYConfig?: import("vxe-table").VxeTablePropTypes.VirtualYConfig | undefined;
+                readonly scrollbarConfig?: import("vxe-table").VxeTablePropTypes.ScrollbarConfig | undefined;
+                readonly params?: any;
+                readonly resizable?: boolean | undefined;
+                readonly highlightCurrentRow?: boolean | undefined;
+                readonly highlightHoverRow?: boolean | undefined;
+                readonly highlightCurrentColumn?: boolean | undefined;
+                readonly highlightHoverColumn?: boolean | undefined;
+                readonly highlightCell?: boolean | undefined;
+                readonly columnKey?: boolean | undefined;
+                readonly rowKey?: boolean | undefined;
+                readonly rowId?: string | undefined;
+                readonly fit?: boolean | undefined;
+                readonly animat?: boolean | undefined;
+                readonly delayHover?: number | undefined;
+                readonly onSelection?: ((params: {
+                    selectedRowKeys: import('..').Key[];
+                    selectedRows: any[];
+                }) => void) | undefined;
+                readonly onReady?: import("vxe-table").VxeGridEvents.Ready<any> | undefined;
+                readonly onInitRendered?: import("vxe-table").VxeGridEvents.InitRendered<any> | undefined;
+                readonly onDataRendered?: import("vxe-table").VxeGridEvents.DataRendered<any> | undefined;
+                readonly onKeydownStart?: import("vxe-table").VxeGridEvents.KeydownStart<any> | undefined;
+                readonly onKeydown?: import("vxe-table").VxeGridEvents.Keydown<any> | undefined;
+                readonly onKeydownEnd?: import("vxe-table").VxeGridEvents.KeydownEnd<any> | undefined;
+                readonly onPaste?: import("vxe-table").VxeGridEvents.Paste<any> | undefined;
+                readonly onCopy?: import("vxe-table").VxeGridEvents.Copy<any> | undefined;
+                readonly onCut?: import("vxe-table").VxeGridEvents.Cut<any> | undefined;
+                readonly onContextMenu?: import("vxe-table").VxeGridEvents.ContextMenu<any> | undefined;
+                readonly onColumnsChange?: import("vxe-table").VxeGridEvents.ColumnsChange<any> | undefined;
+                readonly onDataChange?: import("vxe-table").VxeGridEvents.DataChange<any> | undefined;
+                readonly onFooterDataChange?: import("vxe-table").VxeGridEvents.FooterDataChange<any> | undefined;
+                readonly onCurrentRowChange?: import("vxe-table").VxeGridEvents.CurrentRowChange<any> | undefined;
+                readonly onCurrentRowDisabled?: import("vxe-table").VxeGridEvents.CurrentRowDisabled<any> | undefined;
+                readonly onCurrentColumnChange?: import("vxe-table").VxeGridEvents.CurrentColumnChange<any> | undefined;
+                readonly onCurrentColumnDisabled?: import("vxe-table").VxeGridEvents.CurrentColumnDisabled<any> | undefined;
+                readonly onRadioChange?: import("vxe-table").VxeGridEvents.RadioChange<any> | undefined;
+                readonly onCheckboxChange?: import("vxe-table").VxeGridEvents.CheckboxChange<any> | undefined;
+                readonly onCheckboxAll?: import("vxe-table").VxeGridEvents.CheckboxAll<any> | undefined;
+                readonly onCheckboxRangeStart?: import("vxe-table").VxeGridEvents.CheckboxRangeStart<any> | undefined;
+                readonly onCheckboxRangeChange?: import("vxe-table").VxeGridEvents.CheckboxRangeChange<any> | undefined;
+                readonly onCheckboxRangeEnd?: import("vxe-table").VxeGridEvents.CheckboxRangeEnd<any> | undefined;
+                readonly onCheckboxRangeSelect?: import("vxe-table").VxeGridEvents.CheckboxRangeSelect<any> | undefined;
+                readonly onCellClick?: import("vxe-table").VxeGridEvents.CellClick<any> | undefined;
+                readonly onCellDblclick?: import("vxe-table").VxeGridEvents.CellDblclick<any> | undefined;
+                readonly onCellMenu?: import("vxe-table").VxeGridEvents.CellMenu<any> | undefined;
+                readonly onCellMouseenter?: import("vxe-table").VxeGridEvents.CellMouseenter<any> | undefined;
+                readonly onCellMouseleave?: import("vxe-table").VxeGridEvents.CellMouseleave<any> | undefined;
+                readonly onHeaderCellClick?: import("vxe-table").VxeGridEvents.HeaderCellClick<any> | undefined;
+                readonly onHeaderCellDblclick?: import("vxe-table").VxeGridEvents.HeaderCellDblclick<any> | undefined;
+                readonly onHeaderCellMenu?: import("vxe-table").VxeGridEvents.HeaderCellMenu<any> | undefined;
+                readonly onFooterCellClick?: import("vxe-table").VxeGridEvents.FooterCellClick<any> | undefined;
+                readonly onFooterCellDblclick?: import("vxe-table").VxeGridEvents.FooterCellDblclick<any> | undefined;
+                readonly onFooterCellMenu?: import("vxe-table").VxeGridEvents.FooterCellMenu<any> | undefined;
+                readonly onSortChange?: import("vxe-table").VxeGridEvents.SortChange<any> | undefined;
+                readonly onClearSort?: import("vxe-table").VxeGridEvents.ClearSort<any> | undefined;
+                readonly onClearAllSort?: import("vxe-table").VxeGridEvents.ClearAllSort<any> | undefined;
+                readonly onFilterChange?: import("vxe-table").VxeGridEvents.FilterChange<any> | undefined;
+                readonly onClearFilter?: import("vxe-table").VxeGridEvents.ClearFilter<any> | undefined;
+                readonly onClearAllFilter?: import("vxe-table").VxeGridEvents.ClearAllFilter<any> | undefined;
+                readonly onFilterVisible?: import("vxe-table").VxeGridEvents.FilterVisible<any> | undefined;
+                readonly onResizableChange?: import("vxe-table").VxeGridEvents.ResizableChange<any> | undefined;
+                readonly onToggleRowGroupExpand?: import("vxe-table").VxeGridEvents.ToggleRowGroupExpand<any> | undefined;
+                readonly onToggleRowExpand?: import("vxe-table").VxeGridEvents.ToggleRowExpand<any> | undefined;
+                readonly onToggleTreeExpand?: import("vxe-table").VxeGridEvents.ToggleTreeExpand<any> | undefined;
+                readonly onMenuClick?: import("vxe-table").VxeGridEvents.MenuClick<any> | undefined;
+                readonly onEditClosed?: import("vxe-table").VxeGridEvents.EditClosed<any> | undefined;
+                readonly onEditActivated?: import("vxe-table").VxeGridEvents.EditActivated<any> | undefined;
+                readonly onEditDisabled?: import("vxe-table").VxeGridEvents.EditDisabled<any> | undefined;
+                readonly onValidError?: import("vxe-table").VxeGridEvents.ValidError<any> | undefined;
+                readonly onScroll?: import("vxe-table").VxeGridEvents.Scroll<any> | undefined;
+                readonly onScrollBoundary?: import("vxe-table").VxeGridEvents.ScrollBoundary<any> | undefined;
+                readonly onCustom?: import("vxe-table").VxeGridEvents.Custom<any> | undefined;
+                readonly onRowDragstart?: import("vxe-table").VxeGridEvents.RowDragstart<any> | undefined;
+                readonly onRowDragover?: import("vxe-table").VxeGridEvents.RowDragover<any> | undefined;
+                readonly onRowDragend?: import("vxe-table").VxeGridEvents.RowDragend<any> | undefined;
+                readonly onRowRemoveDragend?: import("vxe-table").VxeGridEvents.RowRemoveDragend<any> | undefined;
+                readonly onRowInsertDragend?: import("vxe-table").VxeGridEvents.RowInsertDragend<any> | undefined;
+                readonly onColumnDragstart?: import("vxe-table").VxeGridEvents.ColumnDragstart<any> | undefined;
+                readonly onColumnDragover?: import("vxe-table").VxeGridEvents.ColumnDragover<any> | undefined;
+                readonly onColumnDragend?: import("vxe-table").VxeGridEvents.ColumnDragend<any> | undefined;
+                readonly onEnterAppendRow?: import("vxe-table").VxeGridEvents.EnterAppendRow<any> | undefined;
+                readonly onProxyQuery?: import("vxe-table").VxeGridEvents.ProxyQuery<any> | undefined;
+                readonly onProxyDelete?: import("vxe-table").VxeGridEvents.ProxyDelete<any> | undefined;
+                readonly onProxySave?: import("vxe-table").VxeGridEvents.ProxySave<any> | undefined;
+                readonly onPageChange?: import("vxe-table").VxeGridEvents.PageChange<any> | undefined;
+                readonly onFormSubmit?: import("vxe-table").VxeGridEvents.FormSubmit<any> | undefined;
+                readonly onFormSubmitInvalid?: import("vxe-table").VxeGridEvents.FormSubmitInvalid<any> | undefined;
+                readonly onFormReset?: import("vxe-table").VxeGridEvents.FormReset<any> | undefined;
+                readonly onFormCollapse?: import("vxe-table").VxeGridEvents.FormCollapse<any> | undefined;
+                readonly onToolbarButtonClick?: import("vxe-table").VxeGridEvents.ToolbarButtonClick<any> | undefined;
+                readonly onToolbarToolClick?: import("vxe-table").VxeGridEvents.ToolbarToolClick<any> | undefined;
+                readonly onZoom?: import("vxe-table").VxeGridEvents.Zoom<any> | undefined;
+                readonly onEditActived?: import("vxe-table").VxeGridEvents.EditActivated<any> | undefined;
+                readonly onOpenFnr?: import("vxe-table").VxeGridEvents.OpenFnr<any> | undefined;
+                readonly onFnrChange?: import("vxe-table").VxeGridEvents.FnrChange<any> | undefined;
+                readonly onFnrFind?: import("vxe-table").VxeGridEvents.FnrFind<any> | undefined;
+                readonly onFnrFindAll?: import("vxe-table").VxeGridEvents.FnrFindAll<any> | undefined;
+                readonly onFnrReplace?: import("vxe-table").VxeGridEvents.FnrReplace<any> | undefined;
+                readonly onFnrReplaceAll?: import("vxe-table").VxeGridEvents.FnrReplaceAll<any> | undefined;
+                readonly onCellAreaCopy?: import("vxe-table").VxeGridEvents.CellAreaCopy<any> | undefined;
+                readonly onCellAreaCut?: import("vxe-table").VxeGridEvents.CellAreaCut<any> | undefined;
+                readonly onCellAreaPaste?: import("vxe-table").VxeGridEvents.CellAreaPaste<any> | undefined;
+                readonly onCellAreaMerge?: import("vxe-table").VxeGridEvents.CellAreaMerge<any> | undefined;
+                readonly onClearCellAreaMerge?: import("vxe-table").VxeGridEvents.ClearCellAreaMerge<any> | undefined;
+                readonly onClearCellAreaSelection?: import("vxe-table").VxeGridEvents.ClearCellAreaSelection<any> | undefined;
+                readonly onHeaderCellAreaSelection?: import("vxe-table").VxeGridEvents.HeaderCellAreaSelection<any> | undefined;
+                readonly onCellAreaSelectionInvalid?: import("vxe-table").VxeGridEvents.CellAreaSelectionInvalid<any> | undefined;
+                readonly onCellAreaSelectionStart?: import("vxe-table").VxeGridEvents.CellAreaSelectionStart<any> | undefined;
+                readonly onCellAreaSelectionDrag?: import("vxe-table").VxeGridEvents.CellAreaSelectionDrag<any> | undefined;
+                readonly onCellAreaSelectionEnd?: import("vxe-table").VxeGridEvents.CellAreaSelectionEnd<any> | undefined;
+                readonly onCellAreaExtensionStart?: import("vxe-table").VxeGridEvents.CellAreaExtensionStart<any> | undefined;
+                readonly onCellAreaExtensionDrag?: import("vxe-table").VxeGridEvents.CellAreaExtensionDrag<any> | undefined;
+                readonly onCellAreaExtensionEnd?: import("vxe-table").VxeGridEvents.CellAreaExtensionEnd<any> | undefined;
+                readonly onCellAreaExtensionFill?: import("vxe-table").VxeGridEvents.CellAreaExtensionFill<any> | undefined;
+                readonly onCellAreaSelectionAllStart?: import("vxe-table").VxeGridEvents.CellAreaSelectionAllStart<any> | undefined;
+                readonly onCellAreaSelectionAllEnd?: import("vxe-table").VxeGridEvents.CellAreaSelectionAllEnd<any> | undefined;
+                readonly onCellAreaArrowsStart?: import("vxe-table").VxeGridEvents.CellAreaArrowsStart<any> | undefined;
+                readonly onCellAreaArrowsEnd?: import("vxe-table").VxeGridEvents.CellAreaArrowsEnd<any> | undefined;
+                readonly onActiveCellChangeStart?: import("vxe-table").VxeGridEvents.ActiveCellChangeStart<any> | undefined;
+                readonly onActiveCellChangeEnd?: import("vxe-table").VxeGridEvents.ActiveCellChangeEnd<any> | undefined;
+                readonly card?: boolean | undefined;
+                readonly toolbarFixed?: boolean | undefined;
+                readonly uid?: string | undefined;
+                readonly immediate?: boolean | undefined;
+                readonly api?: ((...arg: any) => Promise<any>) | undefined;
+                readonly dynamicApi?: ((params?: Recordable<any> | undefined) => (...arg: any) => Promise<any>) | undefined;
+                readonly beforeFetch?: import('@maxax/types').Fn<any, any> | undefined;
+                readonly afterFetch?: import('@maxax/types').Fn<any, any> | undefined;
+                readonly handleSearchInfoFn?: import('@maxax/types').Fn<any, any> | undefined;
+                readonly fetchSetting?: Partial<import('..').FetchSetting> | undefined;
+                readonly defSort?: Recordable<any> | undefined;
+                readonly searchInfo?: Recordable<any> | undefined;
+                readonly useSearchForm?: boolean | undefined;
+                readonly sumFields?: string[] | undefined;
+                readonly avgFields?: string[] | undefined;
+                readonly pagination?: boolean | import('vxe-pc-ui').VxePagerProps | undefined;
+                readonly autoCreateKey?: boolean | undefined;
+                readonly rKey?: string | import('..').GetRowKey | undefined;
+                readonly showTableSetting?: boolean | undefined;
+                readonly tableSetting?: import('..').TableSetting | undefined;
+                readonly showIndexColumn?: boolean | undefined;
+                readonly showSelection?: boolean | undefined;
+                readonly showCheckboxColumn?: boolean | undefined;
+                readonly showRadioColumn?: boolean | undefined;
+                readonly relationForm?: (() => import('..').FormActionType | null) | undefined;
+                readonly "onFetch-success"?: (() => any) | undefined;
+                readonly "onFetch-error"?: (() => any) | undefined;
+                readonly "onSelection-change"?: ((params: import('..').SelectionChangeEventParams) => any) | undefined;
+                readonly "onPage-change"?: ((params: import("vxe-pc-ui").VxePagerDefines.PageChangeEventParams) => any) | undefined;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: any;
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any> | undefined;
+            }>;
+            $root: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import('vue').ComponentProvideOptions>, {}, {}, "", {}, any> | null;
+            $parent: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import('vue').ComponentProvideOptions>, {}, {}, "", {}, any> | null;
+            $host: Element | null;
+            $emit: ((event: "fetch-success") => void) & ((event: "fetch-error") => void) & ((event: "selection-change", params: import('..').SelectionChangeEventParams) => void) & ((event: "page-change", params: import("vxe-pc-ui").VxePagerDefines.PageChangeEventParams) => void);
+            $el: any;
+            $options: import('vue').ComponentOptionsBase<Readonly<import('..').BasicTableProps> & Readonly<{
+                "onFetch-success"?: (() => any) | undefined;
+                "onFetch-error"?: (() => any) | undefined;
+                "onSelection-change"?: ((params: import('..').SelectionChangeEventParams) => any) | undefined;
+                "onPage-change"?: ((params: import("vxe-pc-ui").VxePagerDefines.PageChangeEventParams) => any) | undefined;
+            }>, {
+                emit?: import('..').BasicTableEmitType | undefined;
+                reload: (opt?: import('..').FetchParams | undefined) => Promise<Recordable<any>[] | undefined>;
+                setLoading: (loading: boolean) => void;
+                setProps: (props: Partial<import('..').BasicTableProps>) => void;
+                getTableProps: () => import('..').BasicTableProps;
+                setPagination: (info: Partial<import('vxe-pc-ui').VxePagerProps>) => void;
+                getPaginationRef: () => boolean | import('vxe-pc-ui').VxePagerProps;
+                setShowPagination: (show: boolean) => Promise<void>;
+                getShowPagination: () => boolean;
+                setTableData: <T = Recordable<any>>(values: T[]) => void;
+                getTableData: <T_1 = Recordable<any>>() => T_1[];
+                getDataSource: <T_2 = Recordable<any>>() => T_2[];
+                getRawDataSource: <T_3 = Recordable<any>>() => T_3;
+                getSearchInfo: <T_4 = Recordable<any>>() => T_4;
+                updateTableDataRecord: (keyValue: import('..').Key, record: Recordable<any>) => Recordable<any> | undefined;
+                deleteTableDataRecord: (keyValues: import('..').Key | import('..').Key[]) => void;
+                insertTableDataRecord: (record: Recordable<any> | Recordable<any>[], index?: number | undefined) => Recordable<any>[] | undefined;
+                findTableDataRecord: (keyValue: import('..').Key) => Recordable<any> | undefined;
+                updateTableData: (index: number, key: string, value: any) => Recordable<any>;
+                getTableRowKey: () => string | import('..').GetRowKey | undefined;
+                mergeTableDataRecord: (records: Recordable<any>[], key: import('@maxax/types').KeyValueType) => void;
+                getColumns: (opt?: import('..').GetColumnsParams | undefined) => import('..').BasicColumn[];
+                setColumns: (columns: string[] | import('..').BasicColumn[]) => void;
+                getCacheColumns: () => import('..').BasicColumn[];
+                setCacheColumnsByField?: ((dataIndex: string | undefined, value: import('..').BasicColumn) => void) | undefined;
+                setCacheColumns?: ((columns: import('..').BasicColumn[]) => void) | undefined;
+                setSelectedRowKeys: (keyValues: import('..').BasicTableRowKey[]) => void;
+                getRowSelection: () => import('..').TableRowSelection<Recordable<any>>;
+                setSelectedRows: (rows: Recordable<any>[]) => void;
+                getSelectRows: <T_5 = Recordable<any>>() => T_5[];
+                clearSelectedRowKeys: () => void;
+                getSelectRowKeys: () => import('..').BasicTableRowKey[];
+                deleteSelectRowByKey: (keyValue: import('..').BasicTableRowKey) => void;
+                handleSearchInfoChange: (info?: Recordable<any> | undefined) => void;
+                handleSearchInfoReload: (info?: Recordable<any> | undefined) => void;
+                setSelection: () => Promise<void>;
+                instance: () => import('vxe-table').VxeGridInstance | null;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+                "fetch-success": () => any;
+                "fetch-error": () => any;
+                "selection-change": (params: import('..').SelectionChangeEventParams) => any;
+                "page-change": (params: import("vxe-pc-ui").VxePagerDefines.PageChangeEventParams) => any;
+            }, string, {
+                minHeight: import("vxe-table").VxeTablePropTypes.MinHeight;
+                border: import("vxe-table").VxeTablePropTypes.Border;
+                columns: import("vxe-table").VxeGridPropTypes.Columns<any> & import('..').BasicColumn[];
+                padding: boolean;
+                size: import('vxe-pc-ui').VxeComponentSizeType;
+                api: (...arg: any) => Promise<any>;
+                fetchSetting: Partial<import('..').FetchSetting>;
+                toolbarConfig: import("vxe-table").VxeGridPropTypes.ToolbarConfig;
+                showHeader: boolean;
+                showOverflow: import("vxe-table").VxeTablePropTypes.ShowOverflow;
+                showHeaderOverflow: import("vxe-table").VxeTablePropTypes.ShowOverflow;
+                showFooterOverflow: import("vxe-table").VxeTablePropTypes.ShowOverflow;
+                autoResize: boolean;
+                columnConfig: import("vxe-table").VxeTablePropTypes.ColumnConfig<any>;
+                rowConfig: import("vxe-table").VxeTablePropTypes.RowConfig<any>;
+                customConfig: import("vxe-table").VxeTablePropTypes.CustomConfig<any>;
+                resizeConfig: import("vxe-table").VxeTablePropTypes.ResizeConfig;
+                sortConfig: import("vxe-table").VxeTablePropTypes.SortConfig<any>;
+                radioConfig: import("vxe-table").VxeTablePropTypes.RadioConfig<any>;
+                checkboxConfig: import("vxe-table").VxeTablePropTypes.CheckboxConfig<any>;
+                tooltipConfig: import("vxe-table").VxeTablePropTypes.TooltipConfig<any>;
+                validConfig: import("vxe-table").VxeTablePropTypes.ValidConfig<any>;
+                fit: boolean;
+                delayHover: number;
+                showIndexColumn: boolean;
+                autoCreateKey: boolean;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                beforeCreate?: ((() => void) | (() => void)[]) | undefined;
+                created?: ((() => void) | (() => void)[]) | undefined;
+                beforeMount?: ((() => void) | (() => void)[]) | undefined;
+                mounted?: ((() => void) | (() => void)[]) | undefined;
+                beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
+                updated?: ((() => void) | (() => void)[]) | undefined;
+                activated?: ((() => void) | (() => void)[]) | undefined;
+                deactivated?: ((() => void) | (() => void)[]) | undefined;
+                beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
+                beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
+                destroyed?: ((() => void) | (() => void)[]) | undefined;
+                unmounted?: ((() => void) | (() => void)[]) | undefined;
+                renderTracked?: (((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[]) | undefined;
+                renderTriggered?: (((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[]) | undefined;
+                errorCaptured?: (((err: unknown, instance: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import('vue').ComponentProvideOptions>, {}, {}, "", {}, any> | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import('vue').ComponentProvideOptions>, {}, {}, "", {}, any> | null, info: string) => boolean | void)[]) | undefined;
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import('vue').nextTick;
+            $watch<T_6 extends string | ((...args: any) => any)>(source: T_6, cb: T_6 extends (...args: any) => infer R ? (args_0: R, args_1: R, args_2: import('@vue/reactivity').OnCleanup) => any : (args_0: any, args_1: any, args_2: import('@vue/reactivity').OnCleanup) => any, options?: import('vue').WatchOptions<boolean> | undefined): import('vue').WatchStopHandle;
+        } & Readonly<{
+            minHeight: import("vxe-table").VxeTablePropTypes.MinHeight;
+            border: import("vxe-table").VxeTablePropTypes.Border;
+            columns: import("vxe-table").VxeGridPropTypes.Columns<any> & import('..').BasicColumn[];
+            padding: boolean;
+            size: import('vxe-pc-ui').VxeComponentSizeType;
+            api: (...arg: any) => Promise<any>;
+            fetchSetting: Partial<import('..').FetchSetting>;
+            toolbarConfig: import("vxe-table").VxeGridPropTypes.ToolbarConfig;
+            showHeader: boolean;
+            showOverflow: import("vxe-table").VxeTablePropTypes.ShowOverflow;
+            showHeaderOverflow: import("vxe-table").VxeTablePropTypes.ShowOverflow;
+            showFooterOverflow: import("vxe-table").VxeTablePropTypes.ShowOverflow;
+            autoResize: boolean;
+            columnConfig: import("vxe-table").VxeTablePropTypes.ColumnConfig<any>;
+            rowConfig: import("vxe-table").VxeTablePropTypes.RowConfig<any>;
+            customConfig: import("vxe-table").VxeTablePropTypes.CustomConfig<any>;
+            resizeConfig: import("vxe-table").VxeTablePropTypes.ResizeConfig;
+            sortConfig: import("vxe-table").VxeTablePropTypes.SortConfig<any>;
+            radioConfig: import("vxe-table").VxeTablePropTypes.RadioConfig<any>;
+            checkboxConfig: import("vxe-table").VxeTablePropTypes.CheckboxConfig<any>;
+            tooltipConfig: import("vxe-table").VxeTablePropTypes.TooltipConfig<any>;
+            validConfig: import("vxe-table").VxeTablePropTypes.ValidConfig<any>;
+            fit: boolean;
+            delayHover: number;
+            showIndexColumn: boolean;
+            autoCreateKey: boolean;
+        }> & Omit<Readonly<import('..').BasicTableProps> & Readonly<{
+            "onFetch-success"?: (() => any) | undefined;
+            "onFetch-error"?: (() => any) | undefined;
+            "onSelection-change"?: ((params: import('..').SelectionChangeEventParams) => any) | undefined;
+            "onPage-change"?: ((params: import("vxe-pc-ui").VxePagerDefines.PageChangeEventParams) => any) | undefined;
+        }>, "reload" | "instance" | "emit" | "getSearchInfo" | "getColumns" | "getTableData" | "setPagination" | "setSelection" | "setLoading" | "setProps" | "getTableProps" | "getPaginationRef" | "setShowPagination" | "getShowPagination" | "setTableData" | "getDataSource" | "getRawDataSource" | "updateTableDataRecord" | "deleteTableDataRecord" | "insertTableDataRecord" | "findTableDataRecord" | "updateTableData" | "getTableRowKey" | "mergeTableDataRecord" | "setColumns" | "getCacheColumns" | "setCacheColumnsByField" | "setCacheColumns" | "setSelectedRowKeys" | "getRowSelection" | "setSelectedRows" | "getSelectRows" | "clearSelectedRowKeys" | "getSelectRowKeys" | "deleteSelectRowByKey" | "handleSearchInfoChange" | "handleSearchInfoReload" | ("minHeight" | "border" | "columns" | "padding" | "size" | "api" | "fetchSetting" | "toolbarConfig" | "showHeader" | "showOverflow" | "showHeaderOverflow" | "showFooterOverflow" | "autoResize" | "columnConfig" | "rowConfig" | "customConfig" | "resizeConfig" | "sortConfig" | "radioConfig" | "checkboxConfig" | "tooltipConfig" | "validConfig" | "fit" | "delayHover" | "showIndexColumn" | "autoCreateKey")> & import('vue').ShallowUnwrapRef<{
+            emit?: import('..').BasicTableEmitType | undefined;
+            reload: (opt?: import('..').FetchParams | undefined) => Promise<Recordable<any>[] | undefined>;
+            setLoading: (loading: boolean) => void;
+            setProps: (props: Partial<import('..').BasicTableProps>) => void;
+            getTableProps: () => import('..').BasicTableProps;
+            setPagination: (info: Partial<import('vxe-pc-ui').VxePagerProps>) => void;
+            getPaginationRef: () => boolean | import('vxe-pc-ui').VxePagerProps;
+            setShowPagination: (show: boolean) => Promise<void>;
+            getShowPagination: () => boolean;
+            setTableData: <T = Recordable<any>>(values: T[]) => void;
+            getTableData: <T_1 = Recordable<any>>() => T_1[];
+            getDataSource: <T_2 = Recordable<any>>() => T_2[];
+            getRawDataSource: <T_3 = Recordable<any>>() => T_3;
+            getSearchInfo: <T_4 = Recordable<any>>() => T_4;
+            updateTableDataRecord: (keyValue: import('..').Key, record: Recordable<any>) => Recordable<any> | undefined;
+            deleteTableDataRecord: (keyValues: import('..').Key | import('..').Key[]) => void;
+            insertTableDataRecord: (record: Recordable<any> | Recordable<any>[], index?: number | undefined) => Recordable<any>[] | undefined;
+            findTableDataRecord: (keyValue: import('..').Key) => Recordable<any> | undefined;
+            updateTableData: (index: number, key: string, value: any) => Recordable<any>;
+            getTableRowKey: () => string | import('..').GetRowKey | undefined;
+            mergeTableDataRecord: (records: Recordable<any>[], key: import('@maxax/types').KeyValueType) => void;
+            getColumns: (opt?: import('..').GetColumnsParams | undefined) => import('..').BasicColumn[];
+            setColumns: (columns: string[] | import('..').BasicColumn[]) => void;
+            getCacheColumns: () => import('..').BasicColumn[];
+            setCacheColumnsByField?: ((dataIndex: string | undefined, value: import('..').BasicColumn) => void) | undefined;
+            setCacheColumns?: ((columns: import('..').BasicColumn[]) => void) | undefined;
+            setSelectedRowKeys: (keyValues: import('..').BasicTableRowKey[]) => void;
+            getRowSelection: () => import('..').TableRowSelection<Recordable<any>>;
+            setSelectedRows: (rows: Recordable<any>[]) => void;
+            getSelectRows: <T_5 = Recordable<any>>() => T_5[];
+            clearSelectedRowKeys: () => void;
+            getSelectRowKeys: () => import('..').BasicTableRowKey[];
+            deleteSelectRowByKey: (keyValue: import('..').BasicTableRowKey) => void;
+            handleSearchInfoChange: (info?: Recordable<any> | undefined) => void;
+            handleSearchInfoReload: (info?: Recordable<any> | undefined) => void;
+            setSelection: () => Promise<void>;
+            instance: () => import('vxe-table').VxeGridInstance | null;
+        }> & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: any;
+        }) | null;
+    }, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('./interface').BasicButtonImportPreviewModalProps> & Readonly<{
+        onCancel?: (() => any) | undefined;
+        onConfirm?: ((_data: {
+            data: any[];
+            records: any[];
+        }) => any) | undefined;
+    }>, {
+        show: (context: import('../../composable').BasicDrawerModalContext) => void;
+        hide: () => void;
+    }, {}, {}, {}, {}> | null;
+}, HTMLSpanElement>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=BasicButtonImportPreview.vue.d.ts.map

package/dist/components/basic-button-import-preview/BasicButtonImportPreview.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BasicButtonImportPreview.vue.d.ts","sourceRoot":"","sources":["../../../src/components/basic-button-import-preview/BasicButtonImportPreview.vue"],"names":[],"mappings":"AAyIA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAS9C,OAAO,KAAK,EAAiC,6BAA6B,EAAE,MAAM,aAAa,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwQ/F,wBAAoG;AAapG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}