import type { SelectV2Props as ElementPlusSelectV2Props, Options, Placement, TableColumnCtx, TableProps } from "element-plus";
import type { CSSProperties, Component, PropType } from "vue";
import type { ElSelectorModelValue } from "../components/select/src/select.type";
import type { DefaultRow } from "../components/table/src/table.state";
type Layout = "fixed" | "auto";
/** FaTable 树形数据的字段配置 */
export interface TreeProps {
    hasChildren?: string;
    children?: string;
    checkStrictly?: boolean;
}
/** Element Plus Table 的透传 Props 定义。 */
export declare const tableProps: {
    /**
     * table data
     */
    data: {
        type: PropType<DefaultRow[]>;
        default: () => DefaultRow[];
    };
    /**
     * size of Table
     */
    size: {
        readonly type: PropType<import("element-plus/es/utils/vue/props/types.mjs").EpPropMergeType<StringConstructor, "" | "default" | "large" | "small", never>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    width: (NumberConstructor | StringConstructor)[];
    /**
     * table's height. By default it has an `auto` height. If its value is a number, the height is measured in pixels; if its value is a string, the value will be assigned to element's style.height, the height is affected by external styles
     */
    height: (NumberConstructor | StringConstructor)[];
    /**
     * table's max-height. The legal value is a number or the height in px
     */
    maxHeight: (NumberConstructor | StringConstructor)[];
    /**
     * whether width of column automatically fits its container
     */
    fit: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * whether Table is striped
     */
    stripe: BooleanConstructor;
    /**
     * whether Table has vertical border
     */
    border: BooleanConstructor;
    /**
     * key of row data, used for optimizing rendering. Required if `reserve-selection` is on or display tree data. When its type is String, multi-level access is supported, e.g. `user.info.id`, but `user.info[0].id` is not supported, in which case `Function` should be used
     */
    rowKey: PropType<TableProps<DefaultRow>["rowKey"]>;
    /**
     * whether Table header is visible
     */
    showHeader: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * whether to display a summary row
     */
    showSummary: BooleanConstructor;
    /**
     * displayed text for the first column of summary row
     */
    sumText: StringConstructor;
    /**
     * custom summary method
     */
    summaryMethod: PropType<TableProps<DefaultRow>["summaryMethod"]>;
    /**
     * function that returns custom class names for a row, or a string assigning class names for every row
     */
    rowClassName: PropType<TableProps<DefaultRow>["rowClassName"]>;
    /**
     * function that returns custom style for a row, or an object assigning custom style for every row
     */
    rowStyle: PropType<TableProps<DefaultRow>["rowStyle"]>;
    /**
     * function that returns custom class names for a cell, or a string assigning class names for every cell
     */
    cellClassName: PropType<TableProps<DefaultRow>["cellClassName"]>;
    /**
     * function that returns custom style for a cell, or an object assigning custom style for every cell
     */
    cellStyle: PropType<TableProps<DefaultRow>["cellStyle"]>;
    /**
     * function that returns custom class names for a row in table header, or a string assigning class names for every row in table header
     */
    headerRowClassName: PropType<TableProps<DefaultRow>["headerRowClassName"]>;
    /**
     * function that returns custom style for a row in table header, or an object assigning custom style for every row in table header
     */
    headerRowStyle: PropType<TableProps<DefaultRow>["headerRowStyle"]>;
    /**
     * function that returns custom class names for a cell in table header, or a string assigning class names for every cell in table header
     */
    headerCellClassName: PropType<TableProps<DefaultRow>["headerCellClassName"]>;
    /**
     * function that returns custom style for a cell in table header, or an object assigning custom style for every cell in table header
     */
    headerCellStyle: PropType<TableProps<DefaultRow>["headerCellStyle"]>;
    /**
     * whether current row is highlighted
     */
    highlightCurrentRow: BooleanConstructor;
    /**
     * key of current row, a set only prop
     */
    currentRowKey: (NumberConstructor | StringConstructor)[];
    /**
     * displayed text when data is empty. You can customize this area with `#empty`
     */
    emptyText: StringConstructor;
    /**
     * set expanded rows by this prop, prop's value is the keys of expand rows, you should set row-key before using this prop
     */
    expandRowKeys: PropType<TableProps<DefaultRow>["expandRowKeys"]>;
    /** controls whether a row can be expanded */
    rowExpandable: PropType<TableProps<DefaultRow>["rowExpandable"]>;
    /**
     * whether expand all rows by default, works when the table has a column type="expand" or contains tree structure data
     */
    defaultExpandAll: BooleanConstructor;
    /**
     * set the default sort column and order. property `prop` is used to set default sort column, property `order` is used to set default sort order
     */
    defaultSort: PropType<TableProps<DefaultRow>["defaultSort"]>;
    /**
     * the `effect` of the overflow tooltip
     */
    tooltipEffect: StringConstructor;
    /**
     * the options for the overflow tooltip, [see the following tooltip component](tooltip.html#attributes)
     */
    tooltipOptions: PropType<TableProps<DefaultRow>["tooltipOptions"]>;
    /**
     * method that returns rowspan and colspan
     */
    spanMethod: PropType<TableProps<DefaultRow>["spanMethod"]>;
    /**
     * controls the behavior of master checkbox in multi-select tables when only some rows are selected (but not all). If true, all rows will be selected, else deselected
     */
    selectOnIndeterminate: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * horizontal indentation of tree data
     */
    indent: {
        type: NumberConstructor;
        default: number;
    };
    /**
     * configuration for rendering nested data
     */
    treeProps: {
        type: PropType<TreeProps>;
        default: () => {
            hasChildren: string;
            children: string;
            checkStrictly: boolean;
        };
    };
    /**
     * whether to lazy loading data
     */
    lazy: BooleanConstructor;
    /**
     * method for loading child row data, only works when `lazy` is true
     */
    load: PropType<TableProps<DefaultRow>["load"]>;
    style: {
        type: PropType<CSSProperties>;
        default: () => CSSProperties;
    };
    className: {
        type: StringConstructor;
        default: string;
    };
    /**
     * sets the algorithm used to lay out table cells, rows, and columns
     */
    tableLayout: {
        type: PropType<Layout>;
        default: string;
    };
    /**
     * always show scrollbar
     */
    scrollbarAlwaysOn: BooleanConstructor;
    /**
     * ensure main axis minimum-size doesn't follow the content
     */
    flexible: BooleanConstructor;
    /**
     * whether to hide extra content and show them in a tooltip when hovering on the cell.It will affect all the table columns
     */
    showOverflowTooltip: PropType<TableProps<DefaultRow>["showOverflowTooltip"]>;
    /** formats overflow tooltip content */
    tooltipFormatter: PropType<TableProps<DefaultRow>["tooltipFormatter"]>;
    /** element to which the filter panel is appended */
    appendFilterPanelTo: StringConstructor;
    scrollbarTabindex: {
        type: (NumberConstructor | StringConstructor)[];
        default: undefined;
    };
    /** whether the last column can be resized */
    allowDragLastColumn: {
        type: BooleanConstructor;
        default: boolean;
    };
    /** whether collapsed expanded-row content remains mounted */
    preserveExpandedContent: BooleanConstructor;
    /** whether to use native scrollbars */
    nativeScrollbar: BooleanConstructor;
};
/** Element Plus TableColumn 的透传 Props 定义 */
export declare const tableColumnProps: {
    /**
     * type of the column. If set to `selection`, the column will display checkbox. If set to `index`, the column will display index of the row (staring from 1). If set to `expand`, the column will display expand icon
     */
    type: {
        type: StringConstructor;
        default: string;
    };
    /**
     * column label
     */
    label: StringConstructor;
    /**
     * class name of cells in the column
     */
    className: StringConstructor;
    /**
     * class name of the label of this column
     */
    labelClassName: StringConstructor;
    /**
     *
     */
    property: StringConstructor;
    /**
     * field name. You can also use its alias: `property`
     */
    prop: StringConstructor;
    /**
     * column width
     */
    width: {
        type: (NumberConstructor | StringConstructor)[];
        default: string;
    };
    /**
     * column minimum width. Columns with `width` has a fixed width, while columns with `min-width` has a width that is distributed in proportion
     */
    minWidth: {
        type: (NumberConstructor | StringConstructor)[];
        default: string;
    };
    /**
     * render function for table header of this column
     */
    renderHeader: PropType<TableColumnCtx<DefaultRow>["renderHeader"]>;
    /**
     * whether column can be sorted. Remote sorting can be done by setting this attribute to 'custom' and listening to the `sort-change` event of Table
     */
    sortable: {
        type: (StringConstructor | BooleanConstructor)[];
        default: boolean;
    };
    /**
     * sorting method, works when `sortable` is `true`. Should return a number, just like Array.sort
     */
    sortMethod: PropType<TableColumnCtx<DefaultRow>["sortMethod"]>;
    /**
     * specify which property to sort by, works when `sortable` is `true` and `sort-method` is `undefined`. If set to an Array, the column will sequentially sort by the next property if the previous one is equal
     */
    sortBy: PropType<TableColumnCtx<DefaultRow>["sortBy"]>;
    /**
     * whether column width can be resized, works when `border` of `el-table` is `true`
     */
    resizable: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * column's key. If you need to use the filter-change event, you need this attribute to identify which column is being filtered
     */
    columnKey: StringConstructor;
    /**
     * alignment, the value should be 'left' \/ 'center' \/ 'right'
     */
    align: StringConstructor;
    /**
     * alignment of the table header. If omitted, the value of the above `align` attribute will be applied, the value should be 'left' \/ 'center' \/ 'right'
     */
    headerAlign: StringConstructor;
    /**
     * whether to hide extra content and show them in a tooltip when hovering on the cell
     */
    showOverflowTooltip: {
        type: PropType<TableColumnCtx<DefaultRow>["showOverflowTooltip"]>;
        default: undefined;
    };
    /** function that formats cell tooltip content, works when show-overflow-tooltip is enabled */
    tooltipFormatter: PropType<TableColumnCtx<DefaultRow>["tooltipFormatter"]>;
    /**
     * whether column is fixed at left / right. Will be fixed at left if `true`
     */
    fixed: (StringConstructor | BooleanConstructor)[];
    /**
     * function that formats cell content
     */
    formatter: PropType<TableColumnCtx<DefaultRow>["formatter"]>;
    /**
     * function that determines if a certain row can be selected, works when `type` is 'selection'
     */
    selectable: PropType<TableColumnCtx<DefaultRow>["selectable"]>;
    /**
     * whether to reserve selection after data refreshing, works when `type` is 'selection'. Note that `row-key` is required for this to work
     */
    reserveSelection: BooleanConstructor;
    /**
     * data filtering method. If `filter-multiple` is on, this method will be called multiple times for each row, and a row will display if one of the calls returns `true`
     */
    filterMethod: PropType<TableColumnCtx<DefaultRow>["filterMethod"]>;
    /**
     * filter value for selected data, might be useful when table header is rendered with `render-header`
     */
    filteredValue: PropType<TableColumnCtx<DefaultRow>["filteredValue"]>;
    /**
     * an array of data filtering options. For each element in this array, `text` and `value` are required
     */
    filters: PropType<TableColumnCtx<DefaultRow>["filters"]>;
    /**
     * placement for the filter dropdown
     */
    filterPlacement: StringConstructor;
    /**
     * whether data filtering supports multiple options
     */
    filterMultiple: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * className for the filter dropdown
     */
    filterClassName: StringConstructor;
    /**
     * customize indices for each row, works on columns with `type=index`
     */
    index: PropType<TableColumnCtx<DefaultRow>["index"]>;
    /**
     * the order of the sorting strategies used when sorting the data, works when `sortable` is `true`. Accepts an array, as the user clicks on the header, the column is sorted in order of the elements in the array
     */
    sortOrders: {
        type: PropType<TableColumnCtx<DefaultRow>["sortOrders"]>;
        default: () => (string | null)[];
        validator: (val: unknown) => boolean;
    };
};
/** 传递给底层 Element Plus 虚拟化选择器的扩展 Props。 */
export interface Props {
    label?: string;
    value?: string;
    disabled?: string;
    options?: string;
}
/** Element Plus SelectV2 的透传 Props 定义。 */
export declare const SelectV2Props: {
    ariaLabel: StringConstructor;
    emptyValues: ArrayConstructor;
    valueOnClear: import("element-plus/es/utils/vue/props/types.mjs").EpPropFinalized<(new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null) | (((new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null)) | null)[], unknown, unknown, undefined, boolean>;
    /**
     * whether creating new items is allowed. To use this, `filterable` must be true
     */
    allowCreate: BooleanConstructor;
    /**
     * autocomplete of select input
     */
    autocomplete: {
        type: PropType<"none" | "both" | "inline" | "list">;
        default: string;
    };
    /**
     * for non-filterable Select, this prop decides if the option menu pops up when the input is focused
     */
    automaticDropdown: BooleanConstructor;
    /**
     * whether select can be cleared
     */
    clearable: BooleanConstructor;
    /**
     * custom clear icon
     */
    clearIcon: {
        type: PropType<string | Component>;
        default: import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    };
    /**
     * tooltip theme, built-in theme: `dark` / `light`
     */
    effect: {
        type: PropType<string>;
        default: string;
    };
    /**
     * whether to collapse tags to a text when multiple selecting
     */
    collapseTags: BooleanConstructor;
    /**
     * whether show all selected tags when mouse hover text of collapse-tags. To use this, `collapse-tags` must be true
     */
    collapseTagsTooltip: BooleanConstructor;
    /** collapse-tags tooltip configuration */
    tagTooltip: {
        type: PropType<import("element-plus/es/components/select-v2/src/defaults.mjs").TagTooltipProps>;
        default: () => NonNullable<ElementPlusSelectV2Props["tagTooltip"]>;
    };
    /**
     * The max tags number to be shown. To use this, `collapse-tags` must be true
     */
    maxCollapseTags: {
        type: NumberConstructor;
        default: number;
    };
    /**
     *
     */
    defaultFirstOption: BooleanConstructor;
    /**
     * is disabled
     */
    disabled: BooleanConstructor;
    /**
     *
     */
    estimatedOptionHeight: {
        type: NumberConstructor;
        default: undefined;
    };
    /**
     * is filterable
     */
    filterable: BooleanConstructor;
    /**
     *
     */
    filterMethod: PropType<ElementPlusSelectV2Props["filterMethod"]>;
    /**
     * The height of the dropdown panel, 34px for each item
     */
    height: {
        type: NumberConstructor;
        default: number;
    };
    /**
     * The height of the dropdown item
     */
    itemHeight: {
        type: NumberConstructor;
        default: number;
    };
    /**
     *
     */
    id: StringConstructor;
    /**
     * whether Select is loading data from server
     */
    loading: BooleanConstructor;
    /**
     * displayed text while loading data from server, default is 'Loading'
     */
    loadingText: StringConstructor;
    /**
     * biding value
     */
    modelValue: {
        type: PropType<ElSelectorModelValue>;
    };
    /**
     * is multiple
     */
    multiple: BooleanConstructor;
    /**
     * maximum number of options user can select when multiple is true. No limit when set to 0
     */
    multipleLimit: {
        type: NumberConstructor;
        default: number;
    };
    /**
     * the name attribute of select input
     */
    name: StringConstructor;
    /**
     * displayed text when there is no options, you can also use slot empty, the default is 'No Data'
     */
    noDataText: StringConstructor;
    /**
     * displayed text when no data matches the filtering query, you can also use slot `empty`, default is 'No matching data'
     */
    noMatchText: StringConstructor;
    /**
     * function that gets called when the input value changes. Its parameter is the current input value. To use this, `filterable` must be true
     */
    remoteMethod: PropType<ElementPlusSelectV2Props["remoteMethod"]>;
    /**
     * whether reserve the keyword after select filtered option.
     */
    reserveKeyword: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * data of the options, the key of `value` and `label` can be customize by `props`
     */
    options: {
        type: PropType<import("element-plus/es/components/select-v2/src/select.types.mjs").OptionType[]>;
    };
    /**
     * placeholder, the default is 'Please select'
     */
    placeholder: {
        type: StringConstructor;
    };
    /**
     * whether select dropdown is teleported to the body
     */
    teleported: import("element-plus/es/utils/vue/props/types.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
    /**
     * when select dropdown is inactive and `persistent` is `false`, select dropdown will be destroyed
     */
    persistent: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * custom class name for Select's dropdown
     */
    popperClass: {
        type: StringConstructor;
        default: string;
    };
    /** custom style for Select's dropdown */
    popperStyle: import("element-plus/es/utils/vue/props/types.mjs").EpPropFinalized<(new (...args: any[]) => string | false | CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | ((new (...args: any[]) => string | false | CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | null)[], unknown, unknown, undefined, boolean>;
    /**
     * [popper.js](https://popper.js.org/docs/v2/) parameters
     */
    popperOptions: {
        type: PropType<Partial<Options>>;
        default: () => Partial<Options>;
    };
    /**
     * whether search data from server
     */
    remote: BooleanConstructor;
    /** debounce delay during remote search, in milliseconds */
    debounce: {
        type: NumberConstructor;
        default: number;
    };
    /**
     * size of component
     */
    size: {
        readonly type: PropType<import("element-plus/es/utils/vue/props/types.mjs").EpPropMergeType<StringConstructor, "" | "default" | "large" | "small", never>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    /**
     * configuration options, see the following table
     */
    props: {
        type: PropType<Props>;
        default: () => {
            label: string;
            value: string;
            disabled: string;
            options: string;
        };
    };
    /**
     * unique identity key name for value, required when value is an object
     */
    valueKey: {
        type: StringConstructor;
        default: string;
    };
    /**
     * Controls whether the scrollbar is always displayed
     */
    scrollbarAlwaysOn: BooleanConstructor;
    /**
     * whether to trigger form validation
     */
    validateEvent: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * offset of the dropdown
     */
    offset: {
        type: NumberConstructor;
        default: number;
    };
    /** whether to show the suffix icon during remote search */
    remoteShowSuffix: BooleanConstructor;
    /**
     * Determines whether the arrow is displayed
     */
    showArrow: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * position of dropdown
     */
    placement: {
        type: PropType<Placement>;
        default: string;
    };
    /**
     * list of possible positions for dropdown
     */
    fallbackPlacements: {
        type: PropType<Placement[]>;
        default: string[];
    };
    /**
     * tag type
     */
    tagType: {
        default: string;
        type: PropType<import("element-plus/es/utils/vue/props/types.mjs").EpPropMergeType<StringConstructor, "primary" | "success" | "warning" | "info" | "danger", unknown>>;
        required: false;
        validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    /**
     * tag effect
     */
    tagEffect: {
        default: string;
        type: PropType<import("element-plus/es/utils/vue/props/types.mjs").EpPropMergeType<StringConstructor, "plain" | "dark" | "light", unknown>>;
        required: false;
        validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    /**
     * tabindex for input
     */
    tabindex: {
        type: (NumberConstructor | StringConstructor)[];
        default: number;
    };
    /**
     * which element the select dropdown appends to
     */
    appendTo: StringConstructor;
    /** whether the dropdown width follows the input width, or a fixed width */
    fitInputWidth: {
        type: (NumberConstructor | BooleanConstructor)[];
        default: boolean;
        validator: (value: boolean | number) => boolean;
    };
    /** select suffix icon */
    suffixIcon: {
        type: PropType<string | Component>;
        default: import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    };
};
export {};