import { App } from 'vue';
import { ComponentOptionsMixin } from 'vue';
import { ComponentProvideOptions } from 'vue';
import { DefineComponent } from 'vue';
import { Directive } from 'vue';
import { ExtractPropTypes } from 'vue';
import { JSX } from 'vue/jsx-runtime';
import { PropType } from 'vue';
import { PublicProps } from 'vue';
import { Ref } from 'vue';
import { ShallowReactive } from 'vue';

declare const __VLS_export: __VLS_WithSlots< DefineComponent<ExtractPropTypes<{
    modelValue: PropType<CheckValue>;
    /**
     * 全选框显示文本，默认“全选”
     */
    title: StringConstructor;
    /**
     * 选项数组，数组成员可以是数组或对象
     */
    list: {
        type: PropType<Obj[]>;
        default: () => never[];
    };
    /**
     * 各选项值对应list中的value键。如list是[{v:1,k:2}]，valueKey为 v 且 labelKey为 k, 则选项绑定值为 1，显示文本是 2
     */
    valueKey: {
        type: (StringConstructor | NumberConstructor)[];
        default: number;
    };
    /**
     * 各选项值对应list中的label键。如list是[{v:1,k:2}]，valueKey为 v 且 labelKey为 k, 则选项绑定值为 1，显示文本是 2
     */
    labelKey: {
        type: (StringConstructor | NumberConstructor)[];
        default: number;
    };
    /**
     * 同时设置valueKey & labelKey，优先级相对更高
     */
    keyMap: {
        type: ObjectConstructor;
        default(props: Obj): {
            value: any;
            label: any;
        };
    };
    /**
     * 是否隐藏全选框
     */
    hideAll: BooleanConstructor;
    /**
     * 双向绑定全选框的值，若全选中应为 true，否则 false
     */
    all: BooleanConstructor;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
    [x: string]: any;
}, string, PublicProps, Readonly< ExtractPropTypes<{
    modelValue: PropType<CheckValue>;
    /**
     * 全选框显示文本，默认“全选”
     */
    title: StringConstructor;
    /**
     * 选项数组，数组成员可以是数组或对象
     */
    list: {
        type: PropType<Obj[]>;
        default: () => never[];
    };
    /**
     * 各选项值对应list中的value键。如list是[{v:1,k:2}]，valueKey为 v 且 labelKey为 k, 则选项绑定值为 1，显示文本是 2
     */
    valueKey: {
        type: (StringConstructor | NumberConstructor)[];
        default: number;
    };
    /**
     * 各选项值对应list中的label键。如list是[{v:1,k:2}]，valueKey为 v 且 labelKey为 k, 则选项绑定值为 1，显示文本是 2
     */
    labelKey: {
        type: (StringConstructor | NumberConstructor)[];
        default: number;
    };
    /**
     * 同时设置valueKey & labelKey，优先级相对更高
     */
    keyMap: {
        type: ObjectConstructor;
        default(props: Obj): {
            value: any;
            label: any;
        };
    };
    /**
     * 是否隐藏全选框
     */
    hideAll: BooleanConstructor;
    /**
     * 双向绑定全选框的值，若全选中应为 true，否则 false
     */
    all: BooleanConstructor;
}>> & Readonly<{
    [x: `on${Capitalize<any>}`]: ((...args: any) => any) | undefined;
}>, {
    hideAll: boolean;
    all: boolean;
    list: Obj[];
    valueKey: string | number;
    labelKey: string | number;
    keyMap: Record<string, any>;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>, {
    /**
     * checkbox整体选项区域
     */
    /**
     * checkbox选项内容
     * @param item list子项
     */
    default(_: {
        item: Obj;
    }): any;
}>;

declare const __VLS_export_10: __VLS_WithSlots_7< DefineComponent<ExtractPropTypes<{
    /**
     * 指定日期，默认显示该日期所在月份
     */
    date: DateConstructor;
    /**
     * 传入的额外日期数据
     * 组件始终展示一段日期，但业务上有时需要根据返回的一组日期进行渲染，如 [{date:'2000-01-01',xxx:false},{date:'2000-01-02',xxx:true}]
     */
    dates: PropType<Obj[]>;
    /**
     * 周起始日，默认星期一
     */
    startDay: {
        type: NumberConstructor;
        default: number;
        validator: (val: number) => boolean;
    };
    /**
     * 休息日，默认周六周日
     *
     * @example [5,6] 休息日变为周五周六
     */
    offDay: {
        type: ArrayConstructor;
        default: () => number[];
    };
    /**
     * 传入dates里日期值对应的key，默认“date”
     */
    dateKey: {
        type: StringConstructor;
        default: string;
    };
    /**
     * 单元格标题class
     */
    titleClass: FunctionConstructor;
    /**
     * 每一天单元格class
     */
    dateClass: FunctionConstructor;
    /**
     * 加载状态
     */
    loading: BooleanConstructor;
    /**
     * 单元格日期[格式](https://day.js.org/docs/en/display/format)，默认 YYYY-MM-DD
     */
    textFormat: {
        type: StringConstructor;
        default: string;
    };
    /**
     * 是否将指定date放在第一行，而不是按传统模式将每月1号放在第一行，此时会限定整个42格为起止范围，故可能不会显示完整的某月上下范围
     */
    isOnFirstLine: BooleanConstructor;
    /**
     * 是否开启范围选择
     */
    hasRange: BooleanConstructor;
    /**
     * 非当前有效时间范围内的日期是否可被选入范围
     */
    outerInRange: BooleanConstructor;
    /**
     * 选择一个范围后，再选择时是否先将已选范围清除，即是否可清除已选范围
     */
    clearable: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * 已选范围
     *
     * @example [{_date: '2020-01-01'}, {_date: new Date('2020-01-10')}]
     */
    range: PropType<(Obj & {
        _date: Date | string | number;
    })[]>;
    /**
     * 周标题内容类型，可选mini、short、long
     *
     * @example
     * weekType=mini 对应显示成 一、二、三。。。
     * weekType=short对应显示成 周一、周二、周三。。。
     * weekType=long 对应显示成 星期一、星期二、星期三。。。
     */
    weekType: {
        type: StringConstructor;
        default: string;
    };
    /**
     * 周一到周日对应的映射，若传入有效对象则以该对象的key显示星期标题
     *
     * @example
     * 周六周日标题会分别显示成 “星期6” 和 “星期天”，忽略对应的翻译文本
     * :weekMap={0: '星期天', 6: '星期6'}   *
     */
    weekMap: {
        type: ObjectConstructor;
    };
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    "update:range": (args_0: [MCalendarCell | null, MCalendarCell | null]) => any;
    "select-range": (args_0: [MCalendarCell | null, MCalendarCell | null], args_1: MCalendarCell[]) => any;
    "click-day": (args_0: MCalendarCell, args_1: number) => any;
    "dblclick-day": (args_0: MCalendarCell, args_1: number) => any;
}, string, PublicProps, Readonly< ExtractPropTypes<{
    /**
     * 指定日期，默认显示该日期所在月份
     */
    date: DateConstructor;
    /**
     * 传入的额外日期数据
     * 组件始终展示一段日期，但业务上有时需要根据返回的一组日期进行渲染，如 [{date:'2000-01-01',xxx:false},{date:'2000-01-02',xxx:true}]
     */
    dates: PropType<Obj[]>;
    /**
     * 周起始日，默认星期一
     */
    startDay: {
        type: NumberConstructor;
        default: number;
        validator: (val: number) => boolean;
    };
    /**
     * 休息日，默认周六周日
     *
     * @example [5,6] 休息日变为周五周六
     */
    offDay: {
        type: ArrayConstructor;
        default: () => number[];
    };
    /**
     * 传入dates里日期值对应的key，默认“date”
     */
    dateKey: {
        type: StringConstructor;
        default: string;
    };
    /**
     * 单元格标题class
     */
    titleClass: FunctionConstructor;
    /**
     * 每一天单元格class
     */
    dateClass: FunctionConstructor;
    /**
     * 加载状态
     */
    loading: BooleanConstructor;
    /**
     * 单元格日期[格式](https://day.js.org/docs/en/display/format)，默认 YYYY-MM-DD
     */
    textFormat: {
        type: StringConstructor;
        default: string;
    };
    /**
     * 是否将指定date放在第一行，而不是按传统模式将每月1号放在第一行，此时会限定整个42格为起止范围，故可能不会显示完整的某月上下范围
     */
    isOnFirstLine: BooleanConstructor;
    /**
     * 是否开启范围选择
     */
    hasRange: BooleanConstructor;
    /**
     * 非当前有效时间范围内的日期是否可被选入范围
     */
    outerInRange: BooleanConstructor;
    /**
     * 选择一个范围后，再选择时是否先将已选范围清除，即是否可清除已选范围
     */
    clearable: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * 已选范围
     *
     * @example [{_date: '2020-01-01'}, {_date: new Date('2020-01-10')}]
     */
    range: PropType<(Obj & {
        _date: Date | string | number;
    })[]>;
    /**
     * 周标题内容类型，可选mini、short、long
     *
     * @example
     * weekType=mini 对应显示成 一、二、三。。。
     * weekType=short对应显示成 周一、周二、周三。。。
     * weekType=long 对应显示成 星期一、星期二、星期三。。。
     */
    weekType: {
        type: StringConstructor;
        default: string;
    };
    /**
     * 周一到周日对应的映射，若传入有效对象则以该对象的key显示星期标题
     *
     * @example
     * 周六周日标题会分别显示成 “星期6” 和 “星期天”，忽略对应的翻译文本
     * :weekMap={0: '星期天', 6: '星期6'}   *
     */
    weekMap: {
        type: ObjectConstructor;
    };
}>> & Readonly<{
    "onUpdate:range"?: ((args_0: [MCalendarCell | null, MCalendarCell | null]) => any) | undefined;
    "onSelect-range"?: ((args_0: [MCalendarCell | null, MCalendarCell | null], args_1: MCalendarCell[]) => any) | undefined;
    "onClick-day"?: ((args_0: MCalendarCell, args_1: number) => any) | undefined;
    "onDblclick-day"?: ((args_0: MCalendarCell, args_1: number) => any) | undefined;
}>, {
    loading: boolean;
    textFormat: string;
    clearable: boolean;
    isOnFirstLine: boolean;
    hasRange: boolean;
    outerInRange: boolean;
    startDay: number;
    offDay: unknown[];
    dateKey: string;
    weekType: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>, {
    cell?: (props: {
        day: MCalendarCell;
        index: number;
    }) => any;
}>;

declare const __VLS_export_11: __VLS_WithSlots_8< DefineComponent<ExtractPropTypes<{
    modelValue: BooleanConstructor;
    /**
     * 确定按钮文本
     */
    okText: StringConstructor;
    /**
     * 取消按钮文本
     */
    cancelText: StringConstructor;
    /**
     * 传递给确定按钮的props
     */
    ok: ObjectConstructor;
    /**
     * 确定按钮加载状态
     */
    okLoading: BooleanConstructor;
    /**
     * 确定按钮禁用状态
     */
    okDisabled: BooleanConstructor;
    /**
     * 传递给取消按钮的props
     */
    cancel: ObjectConstructor;
    /**
     * 取消按钮加载状态
     */
    cancelLoading: BooleanConstructor;
    /**
     * 取消按钮禁用状态
     */
    cancelDisabled: BooleanConstructor;
    /**
     * 取消按钮type，默认 text
     */
    cancelType: {
        type: PropType<BtnType>;
        default: string;
    };
    /**
     * 是否把取消按钮放到确定按钮右边
     */
    rightCancel: BooleanConstructor;
    /**
     * 是否显示确定按钮
     */
    hasOk: {
        type: BooleanConstructor;
        default: boolean;
    };
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    "update:modelValue": (val: boolean) => any;
    ok: () => any;
    cancel: () => any;
}, string, PublicProps, Readonly< ExtractPropTypes<{
    modelValue: BooleanConstructor;
    /**
     * 确定按钮文本
     */
    okText: StringConstructor;
    /**
     * 取消按钮文本
     */
    cancelText: StringConstructor;
    /**
     * 传递给确定按钮的props
     */
    ok: ObjectConstructor;
    /**
     * 确定按钮加载状态
     */
    okLoading: BooleanConstructor;
    /**
     * 确定按钮禁用状态
     */
    okDisabled: BooleanConstructor;
    /**
     * 传递给取消按钮的props
     */
    cancel: ObjectConstructor;
    /**
     * 取消按钮加载状态
     */
    cancelLoading: BooleanConstructor;
    /**
     * 取消按钮禁用状态
     */
    cancelDisabled: BooleanConstructor;
    /**
     * 取消按钮type，默认 text
     */
    cancelType: {
        type: PropType<BtnType>;
        default: string;
    };
    /**
     * 是否把取消按钮放到确定按钮右边
     */
    rightCancel: BooleanConstructor;
    /**
     * 是否显示确定按钮
     */
    hasOk: {
        type: BooleanConstructor;
        default: boolean;
    };
}>> & Readonly<{
    "onUpdate:modelValue"?: ((val: boolean) => any) | undefined;
    onOk?: (() => any) | undefined;
    onCancel?: (() => any) | undefined;
}>, {
    modelValue: boolean;
    okLoading: boolean;
    okDisabled: boolean;
    cancelLoading: boolean;
    cancelDisabled: boolean;
    rightCancel: boolean;
    cancelType: BtnType;
    hasOk: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>, {
    other?: (props: {}) => any;
} & {
    action?: (props: {}) => any;
}>;

declare const __VLS_export_12: __VLS_WithSlots_9< DefineComponent<ExtractPropTypes<{
    columns: {
        type: PropType<Obj[]>;
        default: () => never[];
    };
    modelValue: {
        type: PropType<Obj[]>;
        default: () => never[];
    };
    /**
     * 远程请求方法
     *
     * @example
     * const getResult = () => axios.get('').then(res => res.data)
     * <PageTable :method="getResult" />
     */
    method: FunctionConstructor;
    /**
     * 调用 method 时传入的参数或者返回参数的函数
     */
    param: (ObjectConstructor | FunctionConstructor)[];
    /**
     * 返回值中对应的列表数据key
     *
     * @example 如返回结构是 { result: [1,2,3], total: 100 }，则dataKey='result'
     */
    dataKey: StringConstructor;
    /**
     * 返回值中对应的分页总条数key
     *
     * @example 如返回结构是 { result: [1,2,3], total: 100 }，则totalKey='total'
     */
    totalKey: StringConstructor;
    /**
     * 请求时传递的分页参数中 first 对应 key
     * 后端分页一般要求指定起始数据索引或者“页码”，以及获取多少条数据
     *
     * @example
     * 如后端接口给定的分页参数是 firstIndex 对应起始索引
     * pageKey='firstIndex'
     */
    pageKey: StringConstructor;
    /**
     * 请求时传递的分页参数中 size 对应 key
     * 后端分页一般要求指定起始数据索引或者“页码”，以及获取多少条数据
     *
     * @example
     * 如后端接口给定的分页参数是 amount 对应需要获取的条数
     * sizeKey='amount'
     */
    sizeKey: StringConstructor;
    /**
     * 对象形式传递分页参数映射
     */
    pageMap: {
        type: ObjectConstructor;
        default(props: Obj): {
            first: any;
            pageSize: any;
        };
    };
    border: BooleanConstructor;
    /**
     * 处理接口返回列表数据的函数
     */
    process: FunctionConstructor;
    /**
     * 是否本地分页
     */
    isLocal: BooleanConstructor;
    /**
     * 分页条数选项
     */
    pageSizeOpts: {
        type: PropType<number[]>;
        default: () => number[];
    };
    /**
     * 查询失败时不清除之前获取到的结果
     */
    autoRemain: BooleanConstructor;
    /**
     * 计算Table的maxHeight时，Table距离视口底部的距离
     * @default 45
     */
    bottomDis: {
        type: (StringConstructor | NumberConstructor)[];
        default: number;
    };
    /**
     * 勾选项
     */
    selection: ArrayConstructor;
    /**
     * 初始分页条数
     */
    initSize: NumberConstructor;
    /**
     * 远程查询时额外检测的方法
     */
    check: FunctionConstructor;
    /**
     * 查询时是否用页码而不是用当页第一条的索引
     */
    usePageNum: BooleanConstructor;
    /**
     * 是否点击行即更改Checkbox状态
     */
    clickToCheck: BooleanConstructor;
    /**
     * 获取的勾选项是否去除_checked等内部属性
     */
    pure: BooleanConstructor;
    /**
     * head title
     */
    title: StringConstructor;
    /**
     * 是否显示header
     */
    showHeader: BooleanConstructor;
    transfer: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * 最大化时是否全屏
     */
    fullscreen: BooleanConstructor;
    /**
     * 传至ToggleColumn组件的storeAt
     */
    storeAt: StringConstructor;
    /**
     * 隐藏分页
     */
    hidePage: BooleanConstructor;
    /**
     * 自动设置Table的maxHeight
     */
    autoMaxHeight: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Table的maxHeight
     */
    maxHeight: (StringConstructor | NumberConstructor)[];
    /**
     * Table的height
     */
    height: (StringConstructor | NumberConstructor)[];
    /**
     * 自动设置Table的height
     */
    autoHeight: BooleanConstructor;
    /**
     * 最大化时自动计算哪种高度
     */
    maximizeHeightType: {
        type: PropType<"height" | "maxHeight">;
        default: string;
    };
    loading: {
        type: PropType<boolean>;
    };
}>, {
    search: (stay?: boolean) => void;
    setMaxHeight: (isHeight?: boolean) => void;
    table: {
        data: Obj[];
        height: string | number | undefined;
        maxHeight: string | number | undefined;
        selectType: {
            align: string;
            className: string;
            renderHeader: (h: any) => false | JSX.Element;
            render: (h: any, { row, index }: Obj) => any;
        };
    };
    sizer: ShallowReactive<{
        curr: number;
        size: number;
        total: number;
    }>;
    getPage: () => {
        curr: number;
        total: number;
    };
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    "update:modelValue": (val: Obj[]) => any;
    select: (val: Obj, args_1: boolean) => any;
    load: (res: any) => any;
    "update:loading": (value: boolean | undefined) => any;
    "update:selection": (val: Obj[]) => any;
    "select-all": (val: Obj[], args_1: boolean) => any;
    "selection-change": (val: Obj[]) => any;
    reload: () => any;
    "change-col": (val: Obj | Obj[]) => any;
    "maximize-change": (val: boolean) => any;
}, string, PublicProps, Readonly< ExtractPropTypes<{
    columns: {
        type: PropType<Obj[]>;
        default: () => never[];
    };
    modelValue: {
        type: PropType<Obj[]>;
        default: () => never[];
    };
    /**
     * 远程请求方法
     *
     * @example
     * const getResult = () => axios.get('').then(res => res.data)
     * <PageTable :method="getResult" />
     */
    method: FunctionConstructor;
    /**
     * 调用 method 时传入的参数或者返回参数的函数
     */
    param: (ObjectConstructor | FunctionConstructor)[];
    /**
     * 返回值中对应的列表数据key
     *
     * @example 如返回结构是 { result: [1,2,3], total: 100 }，则dataKey='result'
     */
    dataKey: StringConstructor;
    /**
     * 返回值中对应的分页总条数key
     *
     * @example 如返回结构是 { result: [1,2,3], total: 100 }，则totalKey='total'
     */
    totalKey: StringConstructor;
    /**
     * 请求时传递的分页参数中 first 对应 key
     * 后端分页一般要求指定起始数据索引或者“页码”，以及获取多少条数据
     *
     * @example
     * 如后端接口给定的分页参数是 firstIndex 对应起始索引
     * pageKey='firstIndex'
     */
    pageKey: StringConstructor;
    /**
     * 请求时传递的分页参数中 size 对应 key
     * 后端分页一般要求指定起始数据索引或者“页码”，以及获取多少条数据
     *
     * @example
     * 如后端接口给定的分页参数是 amount 对应需要获取的条数
     * sizeKey='amount'
     */
    sizeKey: StringConstructor;
    /**
     * 对象形式传递分页参数映射
     */
    pageMap: {
        type: ObjectConstructor;
        default(props: Obj): {
            first: any;
            pageSize: any;
        };
    };
    border: BooleanConstructor;
    /**
     * 处理接口返回列表数据的函数
     */
    process: FunctionConstructor;
    /**
     * 是否本地分页
     */
    isLocal: BooleanConstructor;
    /**
     * 分页条数选项
     */
    pageSizeOpts: {
        type: PropType<number[]>;
        default: () => number[];
    };
    /**
     * 查询失败时不清除之前获取到的结果
     */
    autoRemain: BooleanConstructor;
    /**
     * 计算Table的maxHeight时，Table距离视口底部的距离
     * @default 45
     */
    bottomDis: {
        type: (StringConstructor | NumberConstructor)[];
        default: number;
    };
    /**
     * 勾选项
     */
    selection: ArrayConstructor;
    /**
     * 初始分页条数
     */
    initSize: NumberConstructor;
    /**
     * 远程查询时额外检测的方法
     */
    check: FunctionConstructor;
    /**
     * 查询时是否用页码而不是用当页第一条的索引
     */
    usePageNum: BooleanConstructor;
    /**
     * 是否点击行即更改Checkbox状态
     */
    clickToCheck: BooleanConstructor;
    /**
     * 获取的勾选项是否去除_checked等内部属性
     */
    pure: BooleanConstructor;
    /**
     * head title
     */
    title: StringConstructor;
    /**
     * 是否显示header
     */
    showHeader: BooleanConstructor;
    transfer: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * 最大化时是否全屏
     */
    fullscreen: BooleanConstructor;
    /**
     * 传至ToggleColumn组件的storeAt
     */
    storeAt: StringConstructor;
    /**
     * 隐藏分页
     */
    hidePage: BooleanConstructor;
    /**
     * 自动设置Table的maxHeight
     */
    autoMaxHeight: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Table的maxHeight
     */
    maxHeight: (StringConstructor | NumberConstructor)[];
    /**
     * Table的height
     */
    height: (StringConstructor | NumberConstructor)[];
    /**
     * 自动设置Table的height
     */
    autoHeight: BooleanConstructor;
    /**
     * 最大化时自动计算哪种高度
     */
    maximizeHeightType: {
        type: PropType<"height" | "maxHeight">;
        default: string;
    };
    loading: {
        type: PropType<boolean>;
    };
}>> & Readonly<{
    "onUpdate:modelValue"?: ((val: Obj[]) => any) | undefined;
    onSelect?: ((val: Obj, args_1: boolean) => any) | undefined;
    onLoad?: ((res: any) => any) | undefined;
    "onUpdate:loading"?: ((value: boolean | undefined) => any) | undefined;
    "onUpdate:selection"?: ((val: Obj[]) => any) | undefined;
    "onSelect-all"?: ((val: Obj[], args_1: boolean) => any) | undefined;
    "onSelection-change"?: ((val: Obj[]) => any) | undefined;
    onReload?: (() => any) | undefined;
    "onChange-col"?: ((val: Obj | Obj[]) => any) | undefined;
    "onMaximize-change"?: ((val: boolean) => any) | undefined;
}>, {
    modelValue: Obj[];
    border: boolean;
    transfer: boolean;
    columns: Obj[];
    isLocal: boolean;
    autoRemain: boolean;
    usePageNum: boolean;
    clickToCheck: boolean;
    pure: boolean;
    showHeader: boolean;
    fullscreen: boolean;
    hidePage: boolean;
    autoHeight: boolean;
    pageMap: Record<string, any>;
    pageSizeOpts: number[];
    bottomDis: string | number;
    autoMaxHeight: boolean;
    maximizeHeightType: "height" | "maxHeight";
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>, {
    [x: string]: ((props: any) => any) | undefined;
    [x: number]: ((props: any) => any) | undefined;
    [x: symbol]: ((props: any) => any) | undefined;
} & {
    title?: (props: {}) => any;
} & {
    headerAction?: (props: {}) => any;
} & {
    header?: (props: {}) => any;
} & {
    footer?: (props: {}) => any;
}>;

declare const __VLS_export_13: __VLS_WithSlots_10< DefineComponent<ExtractPropTypes<{
    modelValue: {
        type: ArrayConstructor;
    };
    title: StringConstructor;
    /**
     * 仅显示图标
     */
    icon: StringConstructor;
    /**
     * 绑定columns对应的唯一标识，一般在v-for中绑定了固定某列且列配置中带有 _visible:false 时用到
     */
    cacheId: (StringConstructor | NumberConstructor)[];
    /**
     * 是否显示全选框
     */
    all: {
        type: BooleanConstructor;
        default: boolean;
    };
    transfer: BooleanConstructor;
    /**
     * 将状态缓存至localStorage中的key，支持a.b形式
     *
     * @example
     * // 组件会尝试将显示状态读写至 localStorage.app.main.cols
     * storeAt='app.main.cols'
     *
     * 特殊情况：如读写至 localStorage.app.page1['part1.list'].cols
     * storeAt='app.page1.[part1.list].cols'
     */
    storeAt: StringConstructor;
    /**
     * 最小可见列数
     */
    minVisible: {
        type: NumberConstructor;
        default: number;
    };
    /**
     * 切换列时是否实时读取本地存储
     *
     * 在启用storeAt时，默认只在初始化时从本地读取一次之前保存的状态 \
     * 若需要每次切换列时都实时从本地获取最新的数据，则可以开启此项 \
     * 一般在搭配其它逻辑共享同一数据结构时适用，如拖拽列宽后需要将列宽存至同一对象中以节省存储空间 \
     * 当在循环中使用（即存在cacheId）时，建议开启此项，否则可能会出现列显示异常的情况
     *
     * @default
     * !!props.storeAt && !!props.cacheId
     */
    realtime: {
        type: BooleanConstructor;
        default: (props: Obj) => boolean;
    };
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    "update:modelValue": (val: Obj[]) => any;
    change: (val: Obj | Obj[]) => any;
}, string, PublicProps, Readonly< ExtractPropTypes<{
    modelValue: {
        type: ArrayConstructor;
    };
    title: StringConstructor;
    /**
     * 仅显示图标
     */
    icon: StringConstructor;
    /**
     * 绑定columns对应的唯一标识，一般在v-for中绑定了固定某列且列配置中带有 _visible:false 时用到
     */
    cacheId: (StringConstructor | NumberConstructor)[];
    /**
     * 是否显示全选框
     */
    all: {
        type: BooleanConstructor;
        default: boolean;
    };
    transfer: BooleanConstructor;
    /**
     * 将状态缓存至localStorage中的key，支持a.b形式
     *
     * @example
     * // 组件会尝试将显示状态读写至 localStorage.app.main.cols
     * storeAt='app.main.cols'
     *
     * 特殊情况：如读写至 localStorage.app.page1['part1.list'].cols
     * storeAt='app.page1.[part1.list].cols'
     */
    storeAt: StringConstructor;
    /**
     * 最小可见列数
     */
    minVisible: {
        type: NumberConstructor;
        default: number;
    };
    /**
     * 切换列时是否实时读取本地存储
     *
     * 在启用storeAt时，默认只在初始化时从本地读取一次之前保存的状态 \
     * 若需要每次切换列时都实时从本地获取最新的数据，则可以开启此项 \
     * 一般在搭配其它逻辑共享同一数据结构时适用，如拖拽列宽后需要将列宽存至同一对象中以节省存储空间 \
     * 当在循环中使用（即存在cacheId）时，建议开启此项，否则可能会出现列显示异常的情况
     *
     * @default
     * !!props.storeAt && !!props.cacheId
     */
    realtime: {
        type: BooleanConstructor;
        default: (props: Obj) => boolean;
    };
}>> & Readonly<{
    "onUpdate:modelValue"?: ((val: Obj[]) => any) | undefined;
    onChange?: ((val: Obj | Obj[]) => any) | undefined;
}>, {
    all: boolean;
    transfer: boolean;
    minVisible: number;
    realtime: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>, {
    default?: (props: {}) => any;
}>;

declare const __VLS_export_2: __VLS_WithSlots_2< DefineComponent<ExtractPropTypes<{
    modelValue: (StringConstructor | NumberConstructor | BooleanConstructor)[];
    /**
     * 打开状态对应值，默认 'T'
     */
    trueValue: {
        type: (StringConstructor | NumberConstructor | BooleanConstructor)[];
        default: string;
    };
    /**
     * 关闭状态对应值，默认 'F'
     */
    falseValue: {
        type: (StringConstructor | NumberConstructor | BooleanConstructor)[];
        default: string;
    };
    /**
     * 打开状态对应文本
     */
    trueLabel: StringConstructor;
    /**
     * 关闭状态对应文本
     */
    falseLabel: StringConstructor;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
    [x: string]: any;
}, string, PublicProps, Readonly< ExtractPropTypes<{
    modelValue: (StringConstructor | NumberConstructor | BooleanConstructor)[];
    /**
     * 打开状态对应值，默认 'T'
     */
    trueValue: {
        type: (StringConstructor | NumberConstructor | BooleanConstructor)[];
        default: string;
    };
    /**
     * 关闭状态对应值，默认 'F'
     */
    falseValue: {
        type: (StringConstructor | NumberConstructor | BooleanConstructor)[];
        default: string;
    };
    /**
     * 打开状态对应文本
     */
    trueLabel: StringConstructor;
    /**
     * 关闭状态对应文本
     */
    falseLabel: StringConstructor;
}>> & Readonly<{
    [x: `on${Capitalize<any>}`]: ((...args: any) => any) | undefined;
}>, {
    trueValue: string | number | boolean;
    falseValue: string | number | boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>, {
    /**
     * 打开状态对应文本
     */
    open(): any;
    /**
     * 关闭状态对应文本
     */
    close(): any;
}>;

declare const __VLS_export_3: __VLS_WithSlots_3< DefineComponent<ExtractPropTypes<{
    /**
     * 前置文本
     */
    prepend: StringConstructor;
    /**
     * 后置文本
     */
    append: StringConstructor;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
    /**
     * 前置文本
     */
    prepend: StringConstructor;
    /**
     * 后置文本
     */
    append: StringConstructor;
}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>, {
    default(): any;
    /**
     * 前置内容
     */
    prepend?(): any;
    /**
     * 后置内容
     */
    append?(): any;
}>;

declare const __VLS_export_4: DefineComponent<ExtractPropTypes<{
    /**
     * 双向绑定最小值
     */
    begin: {
        type: PropType<CountValue>;
        default: null;
    };
    /**
     * 双向绑定最大值
     */
    end: {
        type: PropType<CountValue>;
        default: null;
    };
    /**
     * 允许的最小值，默认0
     */
    min: {
        type: NumberConstructor;
        default: number;
    };
    /**
     * 允许的最大值，默认9999999999
     */
    max: {
        type: NumberConstructor;
        default: number;
    };
    /**
     * 禁用整个组件
     */
    disabled: BooleanConstructor;
    /**
     * 禁用最小值
     */
    minDisabled: BooleanConstructor;
    /**
     * 禁用最大值
     */
    maxDisabled: BooleanConstructor;
    /**
     * 最小值组件class
     */
    minClass: (ArrayConstructor | StringConstructor | ObjectConstructor)[];
    /**
     * 最大值组件class
     */
    maxClass: (ArrayConstructor | StringConstructor | ObjectConstructor)[];
    /**
     * 最小值占位文本
     */
    minHolder: StringConstructor;
    /**
     * 最大值占位文本
     */
    maxHolder: StringConstructor;
    controlsOutside: BooleanConstructor;
    step: NumberConstructor;
    readonly: BooleanConstructor;
    editable: {
        type: BooleanConstructor;
        default: boolean;
    };
    precision: NumberConstructor;
    formatter: FunctionConstructor;
    parser: FunctionConstructor;
    activeChange: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * 传递给最小值组件的props
     */
    minAttr: ObjectConstructor;
    /**
     * 传递给最大值组件的props
     */
    maxAttr: ObjectConstructor;
    /**
     * 中间连接部分class
     */
    joinerClass: (StringConstructor | ObjectConstructor)[];
    /**
     * 是否隐藏连接部分
     */
    hideJoiner: BooleanConstructor;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    change: (begin: number, end: number, isMax: boolean) => any;
    "update:begin": (val: number) => any;
    "update:end": (val: number) => any;
    "change-min": (val: number) => any;
    "change-max": (val: number) => any;
}, string, PublicProps, Readonly< ExtractPropTypes<{
    /**
     * 双向绑定最小值
     */
    begin: {
        type: PropType<CountValue>;
        default: null;
    };
    /**
     * 双向绑定最大值
     */
    end: {
        type: PropType<CountValue>;
        default: null;
    };
    /**
     * 允许的最小值，默认0
     */
    min: {
        type: NumberConstructor;
        default: number;
    };
    /**
     * 允许的最大值，默认9999999999
     */
    max: {
        type: NumberConstructor;
        default: number;
    };
    /**
     * 禁用整个组件
     */
    disabled: BooleanConstructor;
    /**
     * 禁用最小值
     */
    minDisabled: BooleanConstructor;
    /**
     * 禁用最大值
     */
    maxDisabled: BooleanConstructor;
    /**
     * 最小值组件class
     */
    minClass: (ArrayConstructor | StringConstructor | ObjectConstructor)[];
    /**
     * 最大值组件class
     */
    maxClass: (ArrayConstructor | StringConstructor | ObjectConstructor)[];
    /**
     * 最小值占位文本
     */
    minHolder: StringConstructor;
    /**
     * 最大值占位文本
     */
    maxHolder: StringConstructor;
    controlsOutside: BooleanConstructor;
    step: NumberConstructor;
    readonly: BooleanConstructor;
    editable: {
        type: BooleanConstructor;
        default: boolean;
    };
    precision: NumberConstructor;
    formatter: FunctionConstructor;
    parser: FunctionConstructor;
    activeChange: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * 传递给最小值组件的props
     */
    minAttr: ObjectConstructor;
    /**
     * 传递给最大值组件的props
     */
    maxAttr: ObjectConstructor;
    /**
     * 中间连接部分class
     */
    joinerClass: (StringConstructor | ObjectConstructor)[];
    /**
     * 是否隐藏连接部分
     */
    hideJoiner: BooleanConstructor;
}>> & Readonly<{
    onChange?: ((begin: number, end: number, isMax: boolean) => any) | undefined;
    "onUpdate:begin"?: ((val: number) => any) | undefined;
    "onUpdate:end"?: ((val: number) => any) | undefined;
    "onChange-min"?: ((val: number) => any) | undefined;
    "onChange-max"?: ((val: number) => any) | undefined;
}>, {
    disabled: boolean;
    minDisabled: boolean;
    maxDisabled: boolean;
    controlsOutside: boolean;
    readonly: boolean;
    hideJoiner: boolean;
    begin: CountValue;
    end: CountValue;
    min: number;
    max: number;
    editable: boolean;
    activeChange: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare const __VLS_export_5: __VLS_WithSlots_4< DefineComponent<ExtractPropTypes<{
    modelValue: PropType<SelectValue>;
    /**
     * 缓存的唯一键，当页面上同时用到多个不同数据源的CacheSelect时需传入不同值
     */
    cacheId: {
        type: StringConstructor;
        default: string;
    };
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
    [x: string]: any;
}, string, PublicProps, Readonly< ExtractPropTypes<{
    modelValue: PropType<SelectValue>;
    /**
     * 缓存的唯一键，当页面上同时用到多个不同数据源的CacheSelect时需传入不同值
     */
    cacheId: {
        type: StringConstructor;
        default: string;
    };
}>> & Readonly<{
    [x: `on${Capitalize<any>}`]: ((...args: any) => any) | undefined;
}>, {
    cacheId: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>, {
    default?: (props: {
        item: Obj;
        index: number;
    }) => any;
} & {
    dropdown?: (props: {
        list: Obj[];
    }) => any;
} & {
    text?: (props: {
        text: string;
    }) => any;
}>;

declare const __VLS_export_6: DefineComponent<ExtractPropTypes<{
    /**
     * 双向绑定开始时间
     */
    begin: {
        type: (StringConstructor | DateConstructor)[];
        default: string;
    };
    /**
     * 双向绑定结束时间
     */
    end: {
        type: (StringConstructor | DateConstructor)[];
        default: string;
    };
    /**
     * 可选的日期类型：date | month | year | datetime
     */
    type: {
        type: PropType<"month" | "year" | "date" | "datetime">;
        default: string;
    };
    clearable: BooleanConstructor;
    disabled: BooleanConstructor;
    transfer: BooleanConstructor;
    /**
     * 禁用开始时间
     */
    beginDisabled: BooleanConstructor;
    /**
     * 禁用结束时间
     */
    endDisabled: BooleanConstructor;
    /**
     * 是否当所选开始日期大于结束日期时自动将结束日期置为开始日期后一天
     */
    autoNext: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * 是否默认限制开始时间
     */
    limitBegin: {
        type: BooleanConstructor;
        default: boolean;
    };
    beginClass: (ArrayConstructor | StringConstructor | ObjectConstructor)[];
    endClass: (ArrayConstructor | StringConstructor | ObjectConstructor)[];
    /**
     * 开始时间placeholder
     */
    beginHolder: StringConstructor;
    /**
     * 结束时间placeholder
     */
    endHolder: StringConstructor;
    /**
     * 一次性传给开始组件的prop
     */
    beginAttr: ObjectConstructor;
    /**
     * 一次性传给结束组件的prop
     */
    endAttr: ObjectConstructor;
    /**
     * 中间连接符的class
     */
    joinerClass: (StringConstructor | ObjectConstructor)[];
    /**
     * 是否禁止选择今天
     */
    disableToday: BooleanConstructor;
    /**
     * 是否隐藏连接符
     */
    hideJoiner: BooleanConstructor;
    /**
     * iview DatePicer的日期格式
     */
    format: StringConstructor;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    change: (begin: DateValue, end: DateValue, isEnd: boolean) => any;
    "update:begin": (val: DateValue) => any;
    "update:end": (val: DateValue) => any;
    "change-begin": (val: string) => any;
    "change-end": (val: string) => any;
}, string, PublicProps, Readonly< ExtractPropTypes<{
    /**
     * 双向绑定开始时间
     */
    begin: {
        type: (StringConstructor | DateConstructor)[];
        default: string;
    };
    /**
     * 双向绑定结束时间
     */
    end: {
        type: (StringConstructor | DateConstructor)[];
        default: string;
    };
    /**
     * 可选的日期类型：date | month | year | datetime
     */
    type: {
        type: PropType<"month" | "year" | "date" | "datetime">;
        default: string;
    };
    clearable: BooleanConstructor;
    disabled: BooleanConstructor;
    transfer: BooleanConstructor;
    /**
     * 禁用开始时间
     */
    beginDisabled: BooleanConstructor;
    /**
     * 禁用结束时间
     */
    endDisabled: BooleanConstructor;
    /**
     * 是否当所选开始日期大于结束日期时自动将结束日期置为开始日期后一天
     */
    autoNext: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * 是否默认限制开始时间
     */
    limitBegin: {
        type: BooleanConstructor;
        default: boolean;
    };
    beginClass: (ArrayConstructor | StringConstructor | ObjectConstructor)[];
    endClass: (ArrayConstructor | StringConstructor | ObjectConstructor)[];
    /**
     * 开始时间placeholder
     */
    beginHolder: StringConstructor;
    /**
     * 结束时间placeholder
     */
    endHolder: StringConstructor;
    /**
     * 一次性传给开始组件的prop
     */
    beginAttr: ObjectConstructor;
    /**
     * 一次性传给结束组件的prop
     */
    endAttr: ObjectConstructor;
    /**
     * 中间连接符的class
     */
    joinerClass: (StringConstructor | ObjectConstructor)[];
    /**
     * 是否禁止选择今天
     */
    disableToday: BooleanConstructor;
    /**
     * 是否隐藏连接符
     */
    hideJoiner: BooleanConstructor;
    /**
     * iview DatePicer的日期格式
     */
    format: StringConstructor;
}>> & Readonly<{
    onChange?: ((begin: DateValue, end: DateValue, isEnd: boolean) => any) | undefined;
    "onUpdate:begin"?: ((val: DateValue) => any) | undefined;
    "onUpdate:end"?: ((val: DateValue) => any) | undefined;
    "onChange-begin"?: ((val: string) => any) | undefined;
    "onChange-end"?: ((val: string) => any) | undefined;
}>, {
    type: "month" | "year" | "date" | "datetime";
    disabled: boolean;
    hideJoiner: boolean;
    begin: string | Date;
    end: string | Date;
    clearable: boolean;
    transfer: boolean;
    beginDisabled: boolean;
    endDisabled: boolean;
    disableToday: boolean;
    autoNext: boolean;
    limitBegin: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare const __VLS_export_7: DefineComponent<ExtractPropTypes<{
    /**
     * 双向绑定开始时间
     */
    begin: {
        type: (StringConstructor | DateConstructor)[];
        default: string;
    };
    /**
     * 双向绑定结束时间
     */
    end: {
        type: (StringConstructor | DateConstructor)[];
        default: string;
    };
    /**
     * 可选的日期类型：daterange | datetimerange
     */
    type: {
        type: PropType<"daterange" | "datetimerange">;
        default: string;
        validator(value: string): boolean;
    };
    options: ObjectConstructor;
    clearable: {
        type: BooleanConstructor;
        default: boolean;
    };
    splitPanels: BooleanConstructor;
    /**
     * 是否默认限制开始时间
     */
    limitBegin: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * 是否禁止选择今天
     */
    disableToday: BooleanConstructor;
    transfer: BooleanConstructor;
    placeholder: StringConstructor;
    disabled: BooleanConstructor;
    placement: PropType<"top" | "top-start" | "top-end" | "bottom" | "bottom-start" | "bottom-end" | "left" | "left-start" | "left-end" | "right" | "right-start" | "right-end" | undefined>;
    /**
     * 用于格式化绑定时间，默认 YYYY-MM-DD
     */
    valueFormat: {
        type: StringConstructor;
        default: string;
    };
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    change: (dates: string[], type: string) => any;
    "update:begin": (date: string) => any;
    "update:end": (date: string) => any;
}, string, PublicProps, Readonly< ExtractPropTypes<{
    /**
     * 双向绑定开始时间
     */
    begin: {
        type: (StringConstructor | DateConstructor)[];
        default: string;
    };
    /**
     * 双向绑定结束时间
     */
    end: {
        type: (StringConstructor | DateConstructor)[];
        default: string;
    };
    /**
     * 可选的日期类型：daterange | datetimerange
     */
    type: {
        type: PropType<"daterange" | "datetimerange">;
        default: string;
        validator(value: string): boolean;
    };
    options: ObjectConstructor;
    clearable: {
        type: BooleanConstructor;
        default: boolean;
    };
    splitPanels: BooleanConstructor;
    /**
     * 是否默认限制开始时间
     */
    limitBegin: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * 是否禁止选择今天
     */
    disableToday: BooleanConstructor;
    transfer: BooleanConstructor;
    placeholder: StringConstructor;
    disabled: BooleanConstructor;
    placement: PropType<"top" | "top-start" | "top-end" | "bottom" | "bottom-start" | "bottom-end" | "left" | "left-start" | "left-end" | "right" | "right-start" | "right-end" | undefined>;
    /**
     * 用于格式化绑定时间，默认 YYYY-MM-DD
     */
    valueFormat: {
        type: StringConstructor;
        default: string;
    };
}>> & Readonly<{
    onChange?: ((dates: string[], type: string) => any) | undefined;
    "onUpdate:begin"?: ((date: string) => any) | undefined;
    "onUpdate:end"?: ((date: string) => any) | undefined;
}>, {
    type: "daterange" | "datetimerange";
    disabled: boolean;
    begin: string | Date;
    end: string | Date;
    clearable: boolean;
    transfer: boolean;
    disableToday: boolean;
    limitBegin: boolean;
    splitPanels: boolean;
    valueFormat: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare const __VLS_export_8: __VLS_WithSlots_5< DefineComponent<ExtractPropTypes<{
    modelValue: PropType<SelectValue>;
    list: PropType<Obj[]>;
    multiple: BooleanConstructor;
    /**
     * 是否将选项的value作为Option的key，默认以v-for的index作为key
     */
    valueAsKey: BooleanConstructor;
    /**
     * 选项对应value的key
     */
    valueKey: {
        type: StringConstructor;
        default: string;
    };
    /**
     * 选项对应文本的key
     */
    labelKey: {
        type: StringConstructor;
        default: string;
    };
    keyMap: {
        type: ObjectConstructor;
        default(props: Obj): {
            value: any;
            label: any;
        };
    };
    method: FunctionConstructor;
    refresh: FunctionConstructor;
    process: FunctionConstructor;
    param: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
    chosen: (ArrayConstructor | ObjectConstructor)[];
    autoGet: BooleanConstructor;
    formatLabel: {
        type: FunctionConstructor;
    };
    /**
     * 点开再请求时，该函数返回true表示可发送请求
     */
    check: {
        type: FunctionConstructor;
    };
    textMode: BooleanConstructor;
    textFormat: FunctionConstructor;
    /**
     * 关联值，该值变化后会清空绑定值与选项
     *
     * @example 当 some 变化后，<RemoteSelect>的值与选项都会清空
     * <Select v-model="some" ><Option value="1">1</Option></Select>
     * <RemoteSelect :parentCode="some" />
     */
    parentCode: (ArrayConstructor | StringConstructor | NumberConstructor)[];
    optionDisabled: FunctionConstructor;
    optionTag: FunctionConstructor;
    getSelected: {
        type: FunctionConstructor;
        default({ multiple, keyMap, list, value }: {
            multiple: boolean;
            keyMap: {
                value: string;
            };
            list: Obj[];
            value: SelectValue;
        }): Obj | Obj[];
    };
    /**
     * 启用则根据绑定的list判断是否需要在展开时发送请求
     */
    cache: BooleanConstructor;
    loader: FunctionConstructor;
    /**
     * 开启后则展开时仅当parentCode有效才会发送请求
     */
    strict: BooleanConstructor;
    all: {
        type: BooleanConstructor;
        default: boolean;
    };
}>, {
    code: Ref<SelectValue, SelectValue>;
    changeCode: (val: SelectValue) => void;
    loaded: Ref<boolean, boolean>;
    codes: Ref<Obj[], Obj[]>;
    search: () => Promise<void>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    "update:modelValue": (val: SelectValue) => any;
    "update:chosen": (item: Obj) => any;
    "update:list": (list: Obj[]) => any;
    "update:refresh": (handle: () => Promise<void>) => any;
    load: (val: any) => any;
}, string, PublicProps, Readonly< ExtractPropTypes<{
    modelValue: PropType<SelectValue>;
    list: PropType<Obj[]>;
    multiple: BooleanConstructor;
    /**
     * 是否将选项的value作为Option的key，默认以v-for的index作为key
     */
    valueAsKey: BooleanConstructor;
    /**
     * 选项对应value的key
     */
    valueKey: {
        type: StringConstructor;
        default: string;
    };
    /**
     * 选项对应文本的key
     */
    labelKey: {
        type: StringConstructor;
        default: string;
    };
    keyMap: {
        type: ObjectConstructor;
        default(props: Obj): {
            value: any;
            label: any;
        };
    };
    method: FunctionConstructor;
    refresh: FunctionConstructor;
    process: FunctionConstructor;
    param: (StringConstructor | ObjectConstructor | FunctionConstructor)[];
    chosen: (ArrayConstructor | ObjectConstructor)[];
    autoGet: BooleanConstructor;
    formatLabel: {
        type: FunctionConstructor;
    };
    /**
     * 点开再请求时，该函数返回true表示可发送请求
     */
    check: {
        type: FunctionConstructor;
    };
    textMode: BooleanConstructor;
    textFormat: FunctionConstructor;
    /**
     * 关联值，该值变化后会清空绑定值与选项
     *
     * @example 当 some 变化后，<RemoteSelect>的值与选项都会清空
     * <Select v-model="some" ><Option value="1">1</Option></Select>
     * <RemoteSelect :parentCode="some" />
     */
    parentCode: (ArrayConstructor | StringConstructor | NumberConstructor)[];
    optionDisabled: FunctionConstructor;
    optionTag: FunctionConstructor;
    getSelected: {
        type: FunctionConstructor;
        default({ multiple, keyMap, list, value }: {
            multiple: boolean;
            keyMap: {
                value: string;
            };
            list: Obj[];
            value: SelectValue;
        }): Obj | Obj[];
    };
    /**
     * 启用则根据绑定的list判断是否需要在展开时发送请求
     */
    cache: BooleanConstructor;
    loader: FunctionConstructor;
    /**
     * 开启后则展开时仅当parentCode有效才会发送请求
     */
    strict: BooleanConstructor;
    all: {
        type: BooleanConstructor;
        default: boolean;
    };
}>> & Readonly<{
    "onUpdate:modelValue"?: ((val: SelectValue) => any) | undefined;
    "onUpdate:chosen"?: ((item: Obj) => any) | undefined;
    "onUpdate:list"?: ((list: Obj[]) => any) | undefined;
    "onUpdate:refresh"?: ((handle: () => Promise<void>) => any) | undefined;
    onLoad?: ((val: any) => any) | undefined;
}>, {
    all: boolean;
    valueKey: string;
    labelKey: string;
    keyMap: Record<string, any>;
    multiple: boolean;
    valueAsKey: boolean;
    autoGet: boolean;
    textMode: boolean;
    cache: boolean;
    strict: boolean;
    getSelected: Function;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>, {
    default(_: {
        item: Obj;
        index: number;
    }): any;
    dropdown(_: {
        list: Obj[];
    }): any;
    text(_: {
        text: string;
    }): any;
}>;

declare const __VLS_export_9: __VLS_WithSlots_6< DefineComponent<ExtractPropTypes<{
    modelValue: {
        type: PropType<Obj[]>;
        default: () => never[];
    };
    /**
     * iview Table columns
     */
    columns: {
        type: PropType<Obj[]>;
        default: () => never[];
    };
    /**
     * 是否隐藏控制列
     */
    disabled: BooleanConstructor;
    /**
     * 可否增加数据，默认true
     */
    addable: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * 控制列宽度，默认90px
     */
    actionWidth: {
        type: NumberConstructor;
        default: number;
    };
    /**
     * 控制列水平对齐，默认居中
     */
    actionAlign: {
        type: StringConstructor;
        default: string;
    };
    /**
     * 控制列是否固定
     */
    actionFixed: StringConstructor;
    /**
     * 控制列表头文本
     */
    actionText: StringConstructor;
    /**
     * 右侧控制列
     */
    actionCol: {
        type: ObjectConstructor;
        default(props: Obj): {
            key: string;
            slot: string;
            width: any;
            align: any;
            fixed: any;
        };
    };
    /**
     * 新增行时需要添加的数据
     */
    addRow: {
        type: FunctionConstructor;
        default: () => never[];
    };
    border: BooleanConstructor;
    size: StringConstructor;
    /**
     * 控制何时新增数据
     * @param done 新增函数
     */
    beforeAdd: FunctionConstructor;
    /**
     * 控制何时删除数据
     * @param row
     * @param index
     * @param done 删除函数，传入待删除的index
     */
    beforeRemove: FunctionConstructor;
    addBtnType: {
        type: PropType<BtnType>;
        default: string;
    };
    addBtnSize: PropType<BtnSize>;
    addBtnGhost: {
        type: BooleanConstructor;
        default: boolean;
    };
    addBtnDisabled: {
        type: BooleanConstructor;
        default(props: Obj): boolean;
    };
    addBtn: {
        type: ObjectConstructor;
        default: () => {};
    };
    delBtnType: {
        type: PropType<BtnType>;
        default: string;
    };
    delBtnSize: {
        type: PropType<BtnSize>;
        default: string;
    };
    delBtnGhost: {
        type: BooleanConstructor;
        default: boolean;
    };
    delBtn: {
        type: ObjectConstructor;
        default: () => {};
    };
    addText: StringConstructor;
    /**
     * 是否隐藏每行的删除按钮，通过函数返回值决定
     */
    hideDelBtn: FunctionConstructor;
    /**
     * 是否禁用每行删除按钮，通过函数返回值决定
     */
    delBtnDisabled: {
        type: FunctionConstructor;
        default(): boolean;
    };
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    "update:modelValue": (val: Obj[]) => any;
    change: (isAdd: boolean) => any;
    add: (row: Obj) => any;
    remove: (row: Obj) => any;
}, string, PublicProps, Readonly< ExtractPropTypes<{
    modelValue: {
        type: PropType<Obj[]>;
        default: () => never[];
    };
    /**
     * iview Table columns
     */
    columns: {
        type: PropType<Obj[]>;
        default: () => never[];
    };
    /**
     * 是否隐藏控制列
     */
    disabled: BooleanConstructor;
    /**
     * 可否增加数据，默认true
     */
    addable: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * 控制列宽度，默认90px
     */
    actionWidth: {
        type: NumberConstructor;
        default: number;
    };
    /**
     * 控制列水平对齐，默认居中
     */
    actionAlign: {
        type: StringConstructor;
        default: string;
    };
    /**
     * 控制列是否固定
     */
    actionFixed: StringConstructor;
    /**
     * 控制列表头文本
     */
    actionText: StringConstructor;
    /**
     * 右侧控制列
     */
    actionCol: {
        type: ObjectConstructor;
        default(props: Obj): {
            key: string;
            slot: string;
            width: any;
            align: any;
            fixed: any;
        };
    };
    /**
     * 新增行时需要添加的数据
     */
    addRow: {
        type: FunctionConstructor;
        default: () => never[];
    };
    border: BooleanConstructor;
    size: StringConstructor;
    /**
     * 控制何时新增数据
     * @param done 新增函数
     */
    beforeAdd: FunctionConstructor;
    /**
     * 控制何时删除数据
     * @param row
     * @param index
     * @param done 删除函数，传入待删除的index
     */
    beforeRemove: FunctionConstructor;
    addBtnType: {
        type: PropType<BtnType>;
        default: string;
    };
    addBtnSize: PropType<BtnSize>;
    addBtnGhost: {
        type: BooleanConstructor;
        default: boolean;
    };
    addBtnDisabled: {
        type: BooleanConstructor;
        default(props: Obj): boolean;
    };
    addBtn: {
        type: ObjectConstructor;
        default: () => {};
    };
    delBtnType: {
        type: PropType<BtnType>;
        default: string;
    };
    delBtnSize: {
        type: PropType<BtnSize>;
        default: string;
    };
    delBtnGhost: {
        type: BooleanConstructor;
        default: boolean;
    };
    delBtn: {
        type: ObjectConstructor;
        default: () => {};
    };
    addText: StringConstructor;
    /**
     * 是否隐藏每行的删除按钮，通过函数返回值决定
     */
    hideDelBtn: FunctionConstructor;
    /**
     * 是否禁用每行删除按钮，通过函数返回值决定
     */
    delBtnDisabled: {
        type: FunctionConstructor;
        default(): boolean;
    };
}>> & Readonly<{
    "onUpdate:modelValue"?: ((val: Obj[]) => any) | undefined;
    onChange?: ((isAdd: boolean) => any) | undefined;
    onAdd?: ((row: Obj) => any) | undefined;
    onRemove?: ((row: Obj) => any) | undefined;
}>, {
    modelValue: Obj[];
    disabled: boolean;
    border: boolean;
    columns: Obj[];
    addable: boolean;
    actionWidth: number;
    actionAlign: string;
    actionCol: Record<string, any>;
    addRow: Function;
    addBtnType: BtnType;
    addBtnGhost: boolean;
    addBtnDisabled: boolean;
    addBtn: Record<string, any>;
    delBtnType: BtnType;
    delBtnSize: BtnSize;
    delBtnGhost: boolean;
    delBtn: Record<string, any>;
    delBtnDisabled: Function;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>, {
    [x: string]: ((props: any) => any) | undefined;
    [x: number]: ((props: any) => any) | undefined;
    [x: symbol]: ((props: any) => any) | undefined;
} & {
    moreAction?: (props: {
        row: any;
        index: any;
    }) => any;
}>;

declare type __VLS_WithSlots<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithSlots_10<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithSlots_2<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithSlots_3<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithSlots_4<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithSlots_5<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithSlots_6<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithSlots_7<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithSlots_8<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithSlots_9<T, S> = T & {
    new (): {
        $slots: S;
    };
};

export declare const AllCheckbox: typeof __VLS_export;

export declare const BaseSwitch: typeof __VLS_export_2;

declare type BtnSize = '' | 'default' | 'small' | 'large' | undefined;

declare type BtnType = '' | 'default' | 'primary' | 'dashed' | 'text' | 'info' | 'success' | 'warning' | 'error' | undefined;

export declare const CacheSelect: typeof __VLS_export_5;

export declare type CheckValue = (string | number)[];

export declare const Combi: typeof __VLS_export_3;

export declare const CountRange: typeof __VLS_export_4;

export declare type CountValue = number | null | undefined;

export declare const CurdTable: typeof __VLS_export_9;

export declare const DateRange: typeof __VLS_export_6;

export declare const DateRangePicker: typeof __VLS_export_7;

export declare type DateValue = Date | string;

declare const _default: {
    install: typeof install;
};
export default _default;

export declare function install(app: App, opt?: {
    prefix?: string;
    i18n?: any;
    msg?: Obj;
    msgPrefix?: string;
}): void;

export declare const MCalendar: typeof __VLS_export_10;

export declare interface MCalendarCell {
    _date: Date;
    _text: string;
    _isOuter: boolean;
    _isToday: boolean;
    _inRange: boolean | void;
    [x: string]: any;
}

export declare const ModalFooter: typeof __VLS_export_11;

declare interface Obj {
    [x: string]: any;
}

export declare const PageTable: typeof __VLS_export_12;

export declare const RemoteSelect: typeof __VLS_export_8;

export declare type SelectValue = string | number | (string | number)[];

export declare type SwitchValue = string | number | boolean;

export declare const ToggleColumn: typeof __VLS_export_13;

export declare const vIviewSelect: VIViewSelectDirective;

declare type VIViewSelectDirective = Directive<HTMLElement, boolean | undefined>;

export { }


declare module 'vue' {
    interface ComponentCustomProperties {
        vIviewSelect: VIViewSelectDirective;
    }
}