@hinen/pro-element-plus 1.0.0

package/dist/components/DataSelect/props.d.ts

@@ -0,0 +1,116 @@
+import { PropType } from 'vue';
+
+export type DataSelectValueType = string | number | Record<string, any>;
+export interface DataSelectOptionType<Data extends Record<string, any> = Record<string, any>> {
+    label: string;
+    value?: DataSelectValueType;
+    disabled?: boolean;
+    options?: Omit<DataSelectOptionType<Data>, 'options'>[];
+    data?: Data;
+}
+export declare const dataSelectProps: {
+    filterable: PropType<boolean | "remote">;
+    filterOption: PropType<(filterContent: string, option: DataSelectOptionType) => boolean>;
+    disableOption: PropType<(filterContent: string, option: DataSelectOptionType) => boolean>;
+    request: PropType<(filterContent?: string, params?: Record<string, any>) => Promise<DataSelectOptionType[]>>;
+    options: PropType<DataSelectOptionType[]>;
+    valueEnum: PropType<Record<string, string>>;
+    debounceTime: {
+        type: NumberConstructor;
+        default: number;
+    };
+    debounceWaitTime: {
+        type: NumberConstructor;
+        default: number;
+    };
+    params: PropType<Record<string, any>>;
+    ariaLabel: StringConstructor;
+    modelValue: import('element-plus/es/utils/index.mjs').EpPropFinalized<(ArrayConstructor | ObjectConstructor | NumberConstructor | StringConstructor | BooleanConstructor)[], unknown, unknown, undefined, boolean>;
+    disabled: BooleanConstructor;
+    size: {
+        readonly type: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index.mjs').EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    validateEvent: import('element-plus/es/utils/index.mjs').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    name: StringConstructor;
+    id: StringConstructor;
+    tabindex: import('element-plus/es/utils/index.mjs').EpPropFinalized<(NumberConstructor | StringConstructor)[], unknown, unknown, number, boolean>;
+    emptyValues: ArrayConstructor;
+    valueOnClear: import('element-plus/es/utils/index.mjs').EpPropFinalized<readonly [StringConstructor, NumberConstructor, BooleanConstructor, FunctionConstructor], unknown, unknown, undefined, boolean>;
+    autocomplete: import('element-plus/es/utils/index.mjs').EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+    automaticDropdown: BooleanConstructor;
+    effect: import('element-plus/es/utils/index.mjs').EpPropFinalized<(new (...args: any[]) => string) | (() => import('element-plus').PopperEffect) | ((new (...args: any[]) => string) | (() => import('element-plus').PopperEffect))[], unknown, unknown, string, boolean>;
+    clearable: BooleanConstructor;
+    allowCreate: BooleanConstructor;
+    loading: BooleanConstructor;
+    popperClass: import('element-plus/es/utils/index.mjs').EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+    popperOptions: import('element-plus/es/utils/index.mjs').EpPropFinalized<(new (...args: any[]) => Partial<Options>) | (() => Partial<Options>) | ((new (...args: any[]) => Partial<Options>) | (() => Partial<Options>))[], unknown, unknown, () => Partial<Options>, boolean>;
+    loadingText: StringConstructor;
+    noMatchText: StringConstructor;
+    noDataText: StringConstructor;
+    multiple: BooleanConstructor;
+    multipleLimit: import('element-plus/es/utils/index.mjs').EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    placeholder: {
+        readonly type: import('vue/dist/vue.js').PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    defaultFirstOption: BooleanConstructor;
+    reserveKeyword: import('element-plus/es/utils/index.mjs').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    valueKey: import('element-plus/es/utils/index.mjs').EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+    collapseTags: BooleanConstructor;
+    collapseTagsTooltip: BooleanConstructor;
+    maxCollapseTags: import('element-plus/es/utils/index.mjs').EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    teleported: import('element-plus/es/utils/index.mjs').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    persistent: import('element-plus/es/utils/index.mjs').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    clearIcon: {
+        readonly type: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index.mjs').EpPropMergeType<(new (...args: any[]) => (string | import('vue').Component) & {}) | (() => string | import('vue').Component) | ((new (...args: any[]) => (string | import('vue').Component) & {}) | (() => string | import('vue').Component))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    fitInputWidth: BooleanConstructor;
+    suffixIcon: {
+        readonly type: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index.mjs').EpPropMergeType<(new (...args: any[]) => (string | import('vue').Component) & {}) | (() => string | import('vue').Component) | ((new (...args: any[]) => (string | import('vue').Component) & {}) | (() => string | import('vue').Component))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    tagType: {
+        default: string;
+        type: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index.mjs').EpPropMergeType<StringConstructor, "success" | "warning" | "info" | "primary" | "danger", unknown>>;
+        required: false;
+        validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    tagEffect: {
+        default: string;
+        type: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index.mjs').EpPropMergeType<StringConstructor, "dark" | "light" | "plain", unknown>>;
+        required: false;
+        validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    showArrow: import('element-plus/es/utils/index.mjs').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    offset: import('element-plus/es/utils/index.mjs').EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    placement: import('element-plus/es/utils/index.mjs').EpPropFinalized<(new (...args: any[]) => "top" | "bottom" | "left" | "right" | "auto" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => Placement) | ((new (...args: any[]) => "top" | "bottom" | "left" | "right" | "auto" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => Placement))[], Placement, unknown, string, boolean>;
+    fallbackPlacements: import('element-plus/es/utils/index.mjs').EpPropFinalized<(new (...args: any[]) => Placement[]) | (() => Placement[]) | ((new (...args: any[]) => Placement[]) | (() => Placement[]))[], unknown, unknown, string[], boolean>;
+    appendTo: StringConstructor;
+};
+export declare const dataSelectEmits: {
+    'update:modelValue': (value: DataSelectValueType | DataSelectValueType[]) => boolean;
+    change: (value: DataSelectValueType | DataSelectValueType[]) => boolean;
+    focus: (value: FocusEvent) => boolean;
+    blur: (value: FocusEvent) => boolean;
+    clear: () => boolean;
+    'visible-change': (visible: boolean) => boolean;
+    'remove-tag': (value: DataSelectValueType) => boolean;
+    'popup-scroll': (data: {
+        scrollTop: number;
+        scrollLeft: number;
+    }) => boolean;
+    search: (value?: string) => boolean;
+};
+//# sourceMappingURL=props.d.ts.map

package/dist/components/DataSelect/props.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"props.d.ts","sourceRoot":"","sources":["../../../src/components/DataSelect/props.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAC;AAKpC,MAAM,MAAM,mBAAmB,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AAExE,MAAM,WAAW,oBAAoB,CACnC,IAAI,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAEtD,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,EAAE,SAAS,CAAC,EAAE,CAAC;IACxD,IAAI,CAAC,EAAE,IAAI,CAAC;CACb;AAWD,eAAO,MAAM,eAAe;gBAEO,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC;kBACnC,QAAQ,CAChC,CAAC,aAAa,EAAE,MAAM,EAAE,MAAM,EAAE,oBAAoB,KAAK,OAAO,CACjE;mBAC0B,QAAQ,CACjC,CAAC,aAAa,EAAE,MAAM,EAAE,MAAM,EAAE,oBAAoB,KAAK,OAAO,CACjE;aACoB,QAAQ,CAC3B,CACE,aAAa,CAAC,EAAE,MAAM,EACtB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,KACzB,OAAO,CAAC,oBAAoB,EAAE,CAAC,CACrC;aACiB,QAAQ,CAAC,oBAAoB,EAAE,CAAC;eAC7B,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;;;;;;;;;YAGnC,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;;uBAlCvB,iCACR;;;8BAiBV,iBAAK,kBAAkB,iCACf;;;;;0BA8Bq0F,iCAAuB;;;qBAAoqC,iCAAuB;;yBAzDrhI,iCAAuB;yBAiB1B,iCACK;;mBAgBQ,iCACP,wBACX,GAAG,+EAEU,GAAG;;;;wBAQb,iCAAuB;0BAEU,iCAAuB,wBAChD,GAAG,sEAEL,GAClB;;;;;0BAKgL,iCAAuB;;8BAA0H,iBAAK;;;;;;2BAAoO,iCAAuB;qBAAgG,iCAAuB;;;4BAAwL,iCAAuB;uBAAgG,iCAAuB;uBAA+F,iCAAuB;;8BAA0H,iBAAK,kBAAkB,iCAAuB,wBAAwB,GAAG,iCAAiC,KAAK,4CAA4C,KAAK,sBAAsB,GAAG,iCAAiC,KAAK,4CAA4C,KAAK;;;;;;;8BAAqQ,iBAAK,kBAAkB,iCAAuB,wBAAwB,GAAG,iCAAiC,KAAK,4CAA4C,KAAK,sBAAsB,GAAG,iCAAiC,KAAK,4CAA4C,KAAK;;;;;;;qBAA2O,iBAAK,kBAAkB,iCAAuB;;;;;;;qBAA6R,iBAAK,kBAAkB,iCAAuB;;;;;sBAA+X,iCAAuB;mBAA8F,iCAAuB;sBAA+F,iCAAuB,wBAAwB,GAAG,2OAA2O,GAAG;+BAA2S,iCAAuB,wBAAwB,GAAG,4DAA4D,GAAG;;CAd75H,CAAC;AAEF,eAAO,MAAM,eAAe;iCACG,mBAAmB,GAAG,mBAAmB,EAAE;oBAExD,mBAAmB,GAAG,mBAAmB,EAAE;mBAC5C,UAAU;kBACX,UAAU;;gCAEI,OAAO;0BACb,mBAAmB;2BAClB;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE;qBAC/C,MAAM;CACxB,CAAC"}

package/dist/components/DataSelect/types.d.ts

@@ -0,0 +1,25 @@
+import { DataSelectOptionType, dataSelectProps, DataSelectValueType } from './props';
+import { ExtractPropTypes, Slot } from 'vue';
+
+export type DataSelectPropsType = ExtractPropTypes<typeof dataSelectProps>;
+export type DataSelectSlotsType<T extends DataSelectOptionType = DataSelectOptionType> = {
+    default?: Slot<{
+        options: T[];
+    }>;
+    header?: Slot;
+    footer?: Slot;
+    prefix?: Slot;
+    empty?: Slot;
+    loading?: Slot;
+    tag?: Slot<any>;
+    label?: Slot<{
+        label: string;
+        value: DataSelectValueType;
+    }>;
+    option?: Slot<T>;
+};
+export type DataSelectInstanceType = {
+    focus: () => void;
+    blur: () => void;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/components/DataSelect/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/components/DataSelect/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,IAAI,EAAE,MAAM,KAAK,CAAC;AAClD,OAAO,KAAK,EACV,oBAAoB,EACpB,eAAe,EACf,mBAAmB,EACpB,MAAM,SAAS,CAAC;AAEjB,MAAM,MAAM,mBAAmB,GAAG,gBAAgB,CAAC,OAAO,eAAe,CAAC,CAAC;AAE3E,MAAM,MAAM,mBAAmB,CAC7B,CAAC,SAAS,oBAAoB,GAAG,oBAAoB,IACnD;IACF,OAAO,CAAC,EAAE,IAAI,CAAC;QAAE,OAAO,EAAE,CAAC,EAAE,CAAA;KAAE,CAAC,CAAC;IACjC,MAAM,CAAC,EAAE,IAAI,CAAC;IACd,MAAM,CAAC,EAAE,IAAI,CAAC;IACd,MAAM,CAAC,EAAE,IAAI,CAAC;IACd,KAAK,CAAC,EAAE,IAAI,CAAC;IACb,OAAO,CAAC,EAAE,IAAI,CAAC;IACf,GAAG,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC;IAChB,KAAK,CAAC,EAAE,IAAI,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,mBAAmB,CAAA;KAAE,CAAC,CAAC;IAC5D,MAAM,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,IAAI,EAAE,MAAM,IAAI,CAAC;CAClB,CAAC"}

package/dist/components/DataTable/DataTable.vue.d.ts

@@ -0,0 +1,414 @@
+import { DataTableColumnType, DataTableSlotsType } from './types';
+import { TableInstance } from 'element-plus';
+import { QueryFormItemPropsTypeMap, QueryFormInstanceType } from '../QueryForm';
+
+declare function __VLS_template(): Readonly<DataTableSlotsType> & DataTableSlotsType;
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    data: {
+        type: import('vue').PropType<any[]>;
+    };
+    scrollTopOnPagerChange: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    form: {
+        type: import('vue').PropType<Partial<import('..').QueryFormPropsType>>;
+        default: () => Partial<import('..').QueryFormPropsType>;
+    };
+    pagination: {
+        type: import('vue').PropType<false | Partial<import('element-plus').PaginationProps>>;
+        default: () => Partial<import('element-plus').PaginationProps>;
+    };
+    toolbar: {
+        type: import('vue').PropType<import('./types').DataTableToolbarPropsType>;
+        default: () => import('./types').DataTableToolbarPropsType;
+    };
+    columns: {
+        type: import('vue').PropType<DataTableColumnType<keyof QueryFormItemPropsTypeMap, any>[]>;
+        default: () => never[];
+    };
+    forceRefetchOnSearch: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    enabled: {
+        type: import('vue').PropType<import('./types').DataTableQueryEnabledType | boolean>;
+        default: boolean;
+    };
+    gcTime: {
+        type: import('vue').PropType<import('@pinia/colada').UseQueryOptions["gcTime"]>;
+        default: number;
+    };
+    refetchOnMount: {
+        type: import('vue').PropType<import('@pinia/colada').UseQueryOptions["refetchOnMount"]>;
+        default: boolean;
+    };
+    refetchOnReconnect: {
+        type: import('vue').PropType<import('@pinia/colada').UseQueryOptions["refetchOnReconnect"]>;
+        default: boolean;
+    };
+    refetchOnWindowFocus: {
+        type: import('vue').PropType<import('@pinia/colada').UseQueryOptions["refetchOnWindowFocus"]>;
+        default: boolean;
+    };
+    staleTime: {
+        type: import('vue').PropType<import('@pinia/colada').UseQueryOptions["staleTime"]>;
+        default: number;
+    };
+    initialData: import('vue').PropType<import('./types').DataTableQueryInitialDataType>;
+    queryKey: import('vue').PropType<import('./types').DataTableQueryKeyType>;
+    queryFn: import('vue').PropType<import('./types').DataTableQueryFnType>;
+    placeholderData: import('vue').PropType<import('./types').DataTableQueryPlaceholderDataType>;
+    size: {
+        readonly type: import('vue').PropType<import('element-plus/es/utils/index.mjs').EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    width: (NumberConstructor | StringConstructor)[];
+    height: (NumberConstructor | StringConstructor)[];
+    maxHeight: (NumberConstructor | StringConstructor)[];
+    fit: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    stripe: BooleanConstructor;
+    border: BooleanConstructor;
+    rowKey: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults.mjs').DefaultRow>["rowKey"]>;
+    showHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showSummary: BooleanConstructor;
+    sumText: StringConstructor;
+    summaryMethod: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults.mjs').DefaultRow>["summaryMethod"]>;
+    rowClassName: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults.mjs').DefaultRow>["rowClassName"]>;
+    rowStyle: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults.mjs').DefaultRow>["rowStyle"]>;
+    cellClassName: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults.mjs').DefaultRow>["cellClassName"]>;
+    cellStyle: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults.mjs').DefaultRow>["cellStyle"]>;
+    headerRowClassName: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults.mjs').DefaultRow>["headerRowClassName"]>;
+    headerRowStyle: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults.mjs').DefaultRow>["headerRowStyle"]>;
+    headerCellClassName: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults.mjs').DefaultRow>["headerCellClassName"]>;
+    headerCellStyle: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults.mjs').DefaultRow>["headerCellStyle"]>;
+    highlightCurrentRow: BooleanConstructor;
+    currentRowKey: (NumberConstructor | StringConstructor)[];
+    emptyText: StringConstructor;
+    expandRowKeys: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults.mjs').DefaultRow>["expandRowKeys"]>;
+    defaultExpandAll: BooleanConstructor;
+    defaultSort: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults.mjs').DefaultRow>["defaultSort"]>;
+    tooltipEffect: StringConstructor;
+    tooltipOptions: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults.mjs').DefaultRow>["tooltipOptions"]>;
+    spanMethod: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults.mjs').DefaultRow>["spanMethod"]>;
+    selectOnIndeterminate: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    indent: {
+        type: NumberConstructor;
+        default: number;
+    };
+    treeProps: {
+        type: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults.mjs').DefaultRow>["treeProps"]>;
+        default: () => {
+            hasChildren: string;
+            children: string;
+            checkStrictly: boolean;
+        };
+    };
+    lazy: BooleanConstructor;
+    load: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults.mjs').DefaultRow>["load"]>;
+    style: {
+        type: import('vue').PropType<import('vue').CSSProperties>;
+        default: () => {};
+    };
+    className: {
+        type: StringConstructor;
+        default: string;
+    };
+    tableLayout: {
+        type: import('vue').PropType<"fixed" | "auto">;
+        default: string;
+    };
+    scrollbarAlwaysOn: BooleanConstructor;
+    flexible: BooleanConstructor;
+    showOverflowTooltip: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults.mjs').DefaultRow>["showOverflowTooltip"]>;
+    tooltipFormatter: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults.mjs').DefaultRow>["tooltipFormatter"]>;
+    appendFilterPanelTo: StringConstructor;
+    scrollbarTabindex: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: undefined;
+    };
+    allowDragLastColumn: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {
+    clearFormValidate: QueryFormInstanceType["clearValidate"];
+    scrollToFormField: QueryFormInstanceType["scrollToField"];
+    validateForm: QueryFormInstanceType["validate"];
+    validateFormField: QueryFormInstanceType["validateField"];
+    clearSelection: TableInstance["clearSelection"];
+    getSelectionRows: () => any[];
+    toggleRowSelection: (row: any, selected: boolean) => void;
+    toggleAllSelection: TableInstance["toggleAllSelection"];
+    toggleRowExpansion: (row: any, expanded?: boolean | undefined) => void;
+    setCurrentRow: (row: any) => void;
+    clearSort: TableInstance["clearSort"];
+    clearFilter: TableInstance["clearFilter"];
+    doLayout: TableInstance["doLayout"];
+    sort: TableInstance["sort"];
+    scrollTo: TableInstance["scrollTo"];
+    setScrollTop: TableInstance["setScrollTop"];
+    setScrollLeft: TableInstance["setScrollLeft"];
+    refresh: () => Promise<import('@pinia/colada').DataState<import('./types').DataTableQueryFnReturnType<any> | undefined, Error, import('./types').DataTableQueryFnReturnType<any> | undefined>>;
+    refetch: () => Promise<import('@pinia/colada').DataState<import('./types').DataTableQueryFnReturnType<any> | undefined, Error, import('./types').DataTableQueryFnReturnType<any> | undefined>>;
+    getDataSource: () => any[];
+    setCurrentPage: (value: number) => void;
+    setPageSize: (value: number) => void;
+    resetForm: QueryFormInstanceType["resetFields"];
+    resetPagination: () => void;
+    resetAll: () => void;
+    getFormData: () => any;
+    getSearchParams: () => any;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (selection: any[], row: any) => void;
+    expandChange: (row: any, expandedRows: boolean | any[]) => void;
+    currentChange: (currentRow: any, oldCurrentRow: any) => void;
+    scroll: (event: {
+        scrollLeft: number;
+        scrollTop: number;
+    }) => void;
+    selectAll: (selection: any[]) => void;
+    selectionChange: (selection: any[]) => void;
+    cellMouseEnter: (row: any, column: any, cell: HTMLTableCellElement, event: Event) => void;
+    cellMouseLeave: (row: any, column: any, cell: HTMLTableCellElement, event: Event) => void;
+    cellClick: (row: any, column: any, cell: HTMLTableCellElement, event: Event) => void;
+    cellDblclick: (row: any, column: any, cell: HTMLTableCellElement, event: Event) => void;
+    cellContextmenu: (row: any, column: any, cell: HTMLTableCellElement, event: Event) => void;
+    rowClick: (row: any, column: any, event: Event) => void;
+    rowContextmenu: (row: any, column: any, event: Event) => void;
+    rowDblclick: (row: any, column: any, event: Event) => void;
+    headerClick: (column: any, event: Event) => void;
+    headerContextmenu: (column: any, event: Event) => void;
+    sortChange: (data: {
+        column: any;
+        prop: string;
+        order: any;
+    }) => void;
+    filterChange: (newFilters: any) => void;
+    headerDragend: (newWidth: number, oldWidth: number, column: any, event: MouseEvent) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    data: {
+        type: import('vue').PropType<any[]>;
+    };
+    scrollTopOnPagerChange: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    form: {
+        type: import('vue').PropType<Partial<import('..').QueryFormPropsType>>;
+        default: () => Partial<import('..').QueryFormPropsType>;
+    };
+    pagination: {
+        type: import('vue').PropType<false | Partial<import('element-plus').PaginationProps>>;
+        default: () => Partial<import('element-plus').PaginationProps>;
+    };
+    toolbar: {
+        type: import('vue').PropType<import('./types').DataTableToolbarPropsType>;
+        default: () => import('./types').DataTableToolbarPropsType;
+    };
+    columns: {
+        type: import('vue').PropType<DataTableColumnType<keyof QueryFormItemPropsTypeMap, any>[]>;
+        default: () => never[];
+    };
+    forceRefetchOnSearch: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    enabled: {
+        type: import('vue').PropType<import('./types').DataTableQueryEnabledType | boolean>;
+        default: boolean;
+    };
+    gcTime: {
+        type: import('vue').PropType<import('@pinia/colada').UseQueryOptions["gcTime"]>;
+        default: number;
+    };
+    refetchOnMount: {
+        type: import('vue').PropType<import('@pinia/colada').UseQueryOptions["refetchOnMount"]>;
+        default: boolean;
+    };
+    refetchOnReconnect: {
+        type: import('vue').PropType<import('@pinia/colada').UseQueryOptions["refetchOnReconnect"]>;
+        default: boolean;
+    };
+    refetchOnWindowFocus: {
+        type: import('vue').PropType<import('@pinia/colada').UseQueryOptions["refetchOnWindowFocus"]>;
+        default: boolean;
+    };
+    staleTime: {
+        type: import('vue').PropType<import('@pinia/colada').UseQueryOptions["staleTime"]>;
+        default: number;
+    };
+    initialData: import('vue').PropType<import('./types').DataTableQueryInitialDataType>;
+    queryKey: import('vue').PropType<import('./types').DataTableQueryKeyType>;
+    queryFn: import('vue').PropType<import('./types').DataTableQueryFnType>;
+    placeholderData: import('vue').PropType<import('./types').DataTableQueryPlaceholderDataType>;
+    size: {
+        readonly type: import('vue').PropType<import('element-plus/es/utils/index.mjs').EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    width: (NumberConstructor | StringConstructor)[];
+    height: (NumberConstructor | StringConstructor)[];
+    maxHeight: (NumberConstructor | StringConstructor)[];
+    fit: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    stripe: BooleanConstructor;
+    border: BooleanConstructor;
+    rowKey: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults.mjs').DefaultRow>["rowKey"]>;
+    showHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showSummary: BooleanConstructor;
+    sumText: StringConstructor;
+    summaryMethod: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults.mjs').DefaultRow>["summaryMethod"]>;
+    rowClassName: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults.mjs').DefaultRow>["rowClassName"]>;
+    rowStyle: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults.mjs').DefaultRow>["rowStyle"]>;
+    cellClassName: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults.mjs').DefaultRow>["cellClassName"]>;
+    cellStyle: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults.mjs').DefaultRow>["cellStyle"]>;
+    headerRowClassName: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults.mjs').DefaultRow>["headerRowClassName"]>;
+    headerRowStyle: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults.mjs').DefaultRow>["headerRowStyle"]>;
+    headerCellClassName: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults.mjs').DefaultRow>["headerCellClassName"]>;
+    headerCellStyle: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults.mjs').DefaultRow>["headerCellStyle"]>;
+    highlightCurrentRow: BooleanConstructor;
+    currentRowKey: (NumberConstructor | StringConstructor)[];
+    emptyText: StringConstructor;
+    expandRowKeys: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults.mjs').DefaultRow>["expandRowKeys"]>;
+    defaultExpandAll: BooleanConstructor;
+    defaultSort: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults.mjs').DefaultRow>["defaultSort"]>;
+    tooltipEffect: StringConstructor;
+    tooltipOptions: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults.mjs').DefaultRow>["tooltipOptions"]>;
+    spanMethod: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults.mjs').DefaultRow>["spanMethod"]>;
+    selectOnIndeterminate: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    indent: {
+        type: NumberConstructor;
+        default: number;
+    };
+    treeProps: {
+        type: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults.mjs').DefaultRow>["treeProps"]>;
+        default: () => {
+            hasChildren: string;
+            children: string;
+            checkStrictly: boolean;
+        };
+    };
+    lazy: BooleanConstructor;
+    load: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults.mjs').DefaultRow>["load"]>;
+    style: {
+        type: import('vue').PropType<import('vue').CSSProperties>;
+        default: () => {};
+    };
+    className: {
+        type: StringConstructor;
+        default: string;
+    };
+    tableLayout: {
+        type: import('vue').PropType<"fixed" | "auto">;
+        default: string;
+    };
+    scrollbarAlwaysOn: BooleanConstructor;
+    flexible: BooleanConstructor;
+    showOverflowTooltip: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults.mjs').DefaultRow>["showOverflowTooltip"]>;
+    tooltipFormatter: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults.mjs').DefaultRow>["tooltipFormatter"]>;
+    appendFilterPanelTo: StringConstructor;
+    scrollbarTabindex: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: undefined;
+    };
+    allowDragLastColumn: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onSelect?: ((selection: any[], row: any) => any) | undefined;
+    onExpandChange?: ((row: any, expandedRows: boolean | any[]) => any) | undefined;
+    onCurrentChange?: ((currentRow: any, oldCurrentRow: any) => any) | undefined;
+    onScroll?: ((event: {
+        scrollLeft: number;
+        scrollTop: number;
+    }) => any) | undefined;
+    onSelectAll?: ((selection: any[]) => any) | undefined;
+    onSelectionChange?: ((selection: any[]) => any) | undefined;
+    onCellMouseEnter?: ((row: any, column: any, cell: HTMLTableCellElement, event: Event) => any) | undefined;
+    onCellMouseLeave?: ((row: any, column: any, cell: HTMLTableCellElement, event: Event) => any) | undefined;
+    onCellClick?: ((row: any, column: any, cell: HTMLTableCellElement, event: Event) => any) | undefined;
+    onCellDblclick?: ((row: any, column: any, cell: HTMLTableCellElement, event: Event) => any) | undefined;
+    onCellContextmenu?: ((row: any, column: any, cell: HTMLTableCellElement, event: Event) => any) | undefined;
+    onRowClick?: ((row: any, column: any, event: Event) => any) | undefined;
+    onRowContextmenu?: ((row: any, column: any, event: Event) => any) | undefined;
+    onRowDblclick?: ((row: any, column: any, event: Event) => any) | undefined;
+    onHeaderClick?: ((column: any, event: Event) => any) | undefined;
+    onHeaderContextmenu?: ((column: any, event: Event) => any) | undefined;
+    onSortChange?: ((data: {
+        column: any;
+        prop: string;
+        order: any;
+    }) => any) | undefined;
+    onFilterChange?: ((newFilters: any) => any) | undefined;
+    onHeaderDragend?: ((newWidth: number, oldWidth: number, column: any, event: MouseEvent) => any) | undefined;
+}>, {
+    border: boolean;
+    style: import('vue').CSSProperties;
+    loading: boolean;
+    form: Partial<import('..').QueryFormPropsType>;
+    className: string;
+    fit: boolean;
+    stripe: boolean;
+    showHeader: boolean;
+    showSummary: boolean;
+    highlightCurrentRow: boolean;
+    defaultExpandAll: boolean;
+    selectOnIndeterminate: boolean;
+    indent: number;
+    treeProps: import('element-plus/es/components/table/src/table/defaults.mjs').TreeProps | undefined;
+    lazy: boolean;
+    tableLayout: "fixed" | "auto";
+    scrollbarAlwaysOn: boolean;
+    flexible: boolean;
+    scrollbarTabindex: string | number;
+    allowDragLastColumn: boolean;
+    columns: DataTableColumnType<keyof QueryFormItemPropsTypeMap, any>[];
+    gcTime: number | false | undefined;
+    enabled: boolean | import('./types').DataTableQueryEnabledType;
+    refetchOnMount: import('vue').MaybeRefOrGetter<import('@pinia/colada').RefetchOnControl> | undefined;
+    refetchOnReconnect: import('vue').MaybeRefOrGetter<import('@pinia/colada').RefetchOnControl> | undefined;
+    refetchOnWindowFocus: import('vue').MaybeRefOrGetter<import('@pinia/colada').RefetchOnControl> | undefined;
+    staleTime: number | undefined;
+    scrollTopOnPagerChange: boolean;
+    pagination: false | Partial<import('element-plus').PaginationProps>;
+    toolbar: import('./types').DataTableToolbarPropsType;
+    forceRefetchOnSearch: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=DataTable.vue.d.ts.map

package/dist/components/DataTable/DataTable.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DataTable.vue.d.ts","sourceRoot":"","sources":["../../../src/components/DataTable/DataTable.vue"],"names":[],"mappings":"AAaA,OAAO,EAEL,KAAK,yBAAyB,EAC9B,KAAK,qBAAqB,EAC3B,MAAM,cAAc,CAAC;AACtB,OAAO,EAQL,KAAK,aAAa,EACnB,MAAM,cAAc,CAAC;AAEtB,OAAO,KAAK,EACV,mBAAmB,EAEnB,kBAAkB,EAEnB,MAAM,SAAS,CAAC;AA2ajB,iBAAS,cAAc,sDA2ZtB;AAsCD,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qDAprBY,iCAC9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qDAD8B,iCAC9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4EA2rBD,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAAvG,wBAAwG;AACxG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IAAE,QAAO;QAClD,MAAM,EAAE,CAAC,CAAC;KACT,CAAA;CAAE,CAAC"}

package/dist/components/DataTable/constants.d.ts

@@ -0,0 +1,9 @@
+import { EllipsisTextPropsType } from '../EllipsisText';
+import { QueryFormPropsType } from '../QueryForm';
+import { PaginationProps } from 'element-plus';
+
+export declare const DEFAULT_PAGE_SIZE = 20;
+export declare const defaultPaginationProps: Partial<PaginationProps>;
+export declare const defaultEllipsisTextProps: Partial<EllipsisTextPropsType>;
+export declare const defaultFormProps: Partial<QueryFormPropsType>;
+//# sourceMappingURL=constants.d.ts.map

package/dist/components/DataTable/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/components/DataTable/constants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAExD,eAAO,MAAM,iBAAiB,KAAK,CAAC;AAEpC,eAAO,MAAM,sBAAsB,EAAE,OAAO,CAAC,eAAe,CAM3D,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,OAAO,CAAC,qBAAqB,CAGnE,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,OAAO,CAAC,kBAAkB,CAExD,CAAC"}

package/dist/components/DataTable/defineDataTableColumns.d.ts

@@ -0,0 +1,5 @@
+import { DataTableColumnType } from './types';
+import { QueryFormItemPropsTypeMap } from '../QueryForm';
+
+export declare const defineDataTableColumns: <RecordType = any>(columns: DataTableColumnType<keyof QueryFormItemPropsTypeMap, RecordType>[]) => DataTableColumnType<keyof QueryFormItemPropsTypeMap, RecordType>[];
+//# sourceMappingURL=defineDataTableColumns.d.ts.map

package/dist/components/DataTable/defineDataTableColumns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defineDataTableColumns.d.ts","sourceRoot":"","sources":["../../../src/components/DataTable/defineDataTableColumns.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAC;AACzD,OAAO,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAE9C,eAAO,MAAM,sBAAsB,GAAI,UAAU,iBACtC,mBAAmB,CAAC,MAAM,yBAAyB,EAAE,UAAU,CAAC,EAAE,uEACjE,CAAC"}

package/dist/components/DataTable/defineDataTableEnabled.d.ts

@@ -0,0 +1,4 @@
+import { DataTableQueryEnabledType } from './types';
+
+export declare const defineDataTableEnabled: <QueryFormDataType extends Record<string, any> = Record<string, any>>(enabled: boolean | DataTableQueryEnabledType<QueryFormDataType>) => boolean | DataTableQueryEnabledType<QueryFormDataType>;
+//# sourceMappingURL=defineDataTableEnabled.d.ts.map

package/dist/components/DataTable/defineDataTableEnabled.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defineDataTableEnabled.d.ts","sourceRoot":"","sources":["../../../src/components/DataTable/defineDataTableEnabled.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAC;AAEpD,eAAO,MAAM,sBAAsB,GACjC,iBAAiB,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,iCAEpC,OAAO,GAAG,yBAAyB,CAAC,iBAAiB,CAAC,2DACrD,CAAC"}

package/dist/components/DataTable/defineDataTableInitialData.d.ts

@@ -0,0 +1,4 @@
+import { DataTableQueryInitialDataType } from './types';
+
+export declare const defineDataTableInitialData: <RecordType extends Record<string, any> = Record<string, any>, QueryFormDataType extends Record<string, any> = Record<string, any>>(initialData: DataTableQueryInitialDataType<RecordType, QueryFormDataType>) => DataTableQueryInitialDataType<RecordType, QueryFormDataType>;
+//# sourceMappingURL=defineDataTableInitialData.d.ts.map

package/dist/components/DataTable/defineDataTableInitialData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defineDataTableInitialData.d.ts","sourceRoot":"","sources":["../../../src/components/DataTable/defineDataTableInitialData.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAAE,MAAM,SAAS,CAAC;AAExD,eAAO,MAAM,0BAA0B,GACrC,UAAU,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,wBACtC,iBAAiB,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,qCAEhC,6BAA6B,CAAC,UAAU,EAAE,iBAAiB,CAAC,iEAC3D,CAAC"}

package/dist/components/DataTable/defineDataTablePlaceholderData.d.ts

@@ -0,0 +1,4 @@
+import { DataTableQueryPlaceholderDataType } from './types';
+
+export declare const defineDataTablePlaceholderData: <RecordType extends Record<string, any> = Record<string, any>, QueryFormDataType extends Record<string, any> = Record<string, any>>(placeholderData: DataTableQueryPlaceholderDataType<RecordType, QueryFormDataType>) => DataTableQueryPlaceholderDataType<RecordType, QueryFormDataType>;
+//# sourceMappingURL=defineDataTablePlaceholderData.d.ts.map

package/dist/components/DataTable/defineDataTablePlaceholderData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defineDataTablePlaceholderData.d.ts","sourceRoot":"","sources":["../../../src/components/DataTable/defineDataTablePlaceholderData.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iCAAiC,EAAE,MAAM,SAAS,CAAC;AAE5D,eAAO,MAAM,8BAA8B,GACzC,UAAU,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,wBACtC,iBAAiB,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,yCAE5B,iCAAiC,CAChD,UAAU,EACV,iBAAiB,CAClB,qEACiB,CAAC"}

package/dist/components/DataTable/defineDataTableQueryFn.d.ts

@@ -0,0 +1,4 @@
+import { DataTableQueryFnType } from './types';
+
+export declare const defineDataTableQueryFn: <RecordType extends Record<string, any> = Record<string, any>, QueryFormDataType extends Record<string, any> = Record<string, any>>(queryFn: DataTableQueryFnType<RecordType, QueryFormDataType>) => DataTableQueryFnType<RecordType, QueryFormDataType>;
+//# sourceMappingURL=defineDataTableQueryFn.d.ts.map