import { getNode } from '@xiaohaih/condition-core';

/**
 * @file 复选框
 */
declare const _default: import('vue').DefineComponent<{
    readonly labelKey: {
        readonly type: import('vue').PropType<string>;
        readonly default: "label";
    };
    readonly valueKey: {
        readonly type: import('vue').PropType<string>;
        readonly default: "value";
    };
    readonly type: {
        readonly type: import('vue').PropType<"checkbox" | "button">;
    };
    readonly multiple: {
        readonly type: import('vue').PropType<boolean>;
        readonly default: true;
    };
    readonly disabledKey: {
        readonly type: import('vue').PropType<string>;
        readonly default: "disabled";
    };
    readonly class: {
        type: import('vue').PropType<string | Record<string, any> | any[]>;
    };
    readonly style: {
        type: import('vue').PropType<string | Record<string, any> | any[]>;
    };
    readonly prop: {
        type: import('vue').PropType<string | string[]>;
    };
    readonly postfix: {
        type: import('vue').PropType<string | import('vue').VNode | ((...args: any[]) => import('vue').VNode)>;
    };
    readonly as: {
        type: import('vue').PropType<string>;
    };
    readonly conditionSortIndex: {
        type: import('vue').PropType<number>;
    };
    readonly dynamicFields: {
        type: import('vue').PropType<(option: {
            query: Record<string, any>;
        }) => Record<string, any> | void>;
    };
    readonly formDynamicFields: {
        type: import('vue').PropType<(option: {
            query: Record<string, any>;
        }) => Record<string, any> | void>;
    };
    readonly slotDefault: {
        type: import('vue').PropType<import('vue').VNode | ((option: import('../share').SlotQuery) => import('vue').VNode)>;
    };
    readonly slotBefore: {
        type: import('vue').PropType<import('vue').VNode | ((option: import('../share').SlotQuery) => import('vue').VNode)>;
    };
    readonly slotAfter: {
        type: import('vue').PropType<import('vue').VNode | ((option: import('../share').SlotQuery) => import('vue').VNode)>;
    };
    readonly fields: {
        readonly type: import('vue').PropType<string[]>;
    };
    readonly backfillToValue: {
        readonly type: import('vue').PropType<(values: string | string[], fields: string | string[], backfill?: Record<string, any>) => string | string[]>;
        readonly default: (v: any) => any;
    };
    readonly options: {
        readonly type: import('vue').PropType<Record<string, any>[]>;
        readonly default: () => never[];
    };
    readonly getOptions: {
        readonly type: import('vue').PropType<import('@xiaohaih/condition-core').GetOptions>;
    };
    readonly field: {
        readonly type: import('vue').PropType<string>;
        readonly required: true;
    };
    readonly query: {
        readonly type: import('vue').PropType<Record<string, any>>;
        readonly required: true;
    };
    readonly backfill: {
        readonly type: import('vue').PropType<Record<string, any>>;
    };
    readonly disabled: {
        readonly type: import('vue').PropType<import('@xiaohaih/condition-core').HideOption>;
    };
    readonly hide: {
        readonly type: import('vue').PropType<import('@xiaohaih/condition-core').HideOption>;
    };
    readonly depend: {
        readonly type: import('vue').PropType<boolean>;
    };
    readonly resetByDependValueChange: {
        readonly type: import('vue').PropType<boolean | ((query: Record<string, any>) => boolean)>;
        readonly default: true;
    };
    readonly dependFields: {
        readonly type: import('vue').PropType<string | string[]>;
    };
    readonly dependWatchOption: {
        readonly type: import('vue').PropType<import('vue').WatchOptions>;
    };
    readonly optionsDepend: {
        readonly type: import('vue').PropType<boolean>;
    };
    readonly optionsDependFields: {
        readonly type: import('vue').PropType<string | string[]>;
    };
    readonly resetToInitialValue: {
        readonly type: import('vue').PropType<boolean>;
    };
    readonly emptyValue: {
        readonly type: import('vue').PropType<undefined | null | boolean | string | number>;
        readonly default: undefined;
    };
    readonly validator: {
        readonly type: import('vue').PropType<((query: Record<string, any>) => any) | ((query: Record<string, any>) => Promise<any>)>;
    };
    readonly customGetQuery: {
        readonly type: import('vue').PropType<import('@xiaohaih/condition-core').GetQuery>;
    };
    readonly defaultValue: {
        readonly type: import('vue').PropType<import('@xiaohaih/condition-core').ValueType | ((query: Record<string, any>, backfill?: Record<string, any>) => import('@xiaohaih/condition-core').ValueType)>;
        readonly default: undefined;
    };
    readonly ariaControls: StringConstructor;
    readonly modelValue: {
        type: (NumberConstructor | StringConstructor | BooleanConstructor)[];
        default: undefined;
    };
    readonly value: {
        type: (ObjectConstructor | NumberConstructor | StringConstructor | BooleanConstructor)[];
        default: undefined;
    };
    readonly indeterminate: BooleanConstructor;
    readonly checked: BooleanConstructor;
    readonly name: {
        type: StringConstructor;
        default: undefined;
    };
    readonly trueValue: {
        type: (NumberConstructor | StringConstructor)[];
        default: undefined;
    };
    readonly falseValue: {
        type: (NumberConstructor | StringConstructor)[];
        default: undefined;
    };
    readonly trueLabel: {
        type: (NumberConstructor | StringConstructor)[];
        default: undefined;
    };
    readonly falseLabel: {
        type: (NumberConstructor | StringConstructor)[];
        default: undefined;
    };
    readonly id: {
        type: StringConstructor;
        default: undefined;
    };
    readonly border: BooleanConstructor;
    readonly size: {
        readonly type: import('vue').PropType<"" | "default" | "small" | "large">;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    readonly tabindex: (NumberConstructor | StringConstructor)[];
    readonly validateEvent: {
        type: BooleanConstructor;
        default: boolean;
    };
}, {
    formItemProps: import('vue').ComputedRef<Readonly<import('@vue/shared').LooseRequired<Readonly<import('vue').ExtractPropTypes<{
        readonly labelKey: {
            readonly type: import('vue').PropType<string>;
            readonly default: "label";
        };
        readonly valueKey: {
            readonly type: import('vue').PropType<string>;
            readonly default: "value";
        };
        readonly type: {
            readonly type: import('vue').PropType<"checkbox" | "button">;
        };
        readonly multiple: {
            readonly type: import('vue').PropType<boolean>;
            readonly default: true;
        };
        readonly disabledKey: {
            readonly type: import('vue').PropType<string>;
            readonly default: "disabled";
        };
        readonly class: {
            type: import('vue').PropType<string | Record<string, any> | any[]>;
        };
        readonly style: {
            type: import('vue').PropType<string | Record<string, any> | any[]>;
        };
        readonly prop: {
            type: import('vue').PropType<string | string[]>;
        };
        readonly postfix: {
            type: import('vue').PropType<string | import('vue').VNode | ((...args: any[]) => import('vue').VNode)>;
        };
        readonly as: {
            type: import('vue').PropType<string>;
        };
        readonly conditionSortIndex: {
            type: import('vue').PropType<number>;
        };
        readonly dynamicFields: {
            type: import('vue').PropType<(option: {
                query: Record<string, any>;
            }) => Record<string, any> | void>;
        };
        readonly formDynamicFields: {
            type: import('vue').PropType<(option: {
                query: Record<string, any>;
            }) => Record<string, any> | void>;
        };
        readonly slotDefault: {
            type: import('vue').PropType<import('vue').VNode | ((option: import('../share').SlotQuery) => import('vue').VNode)>;
        };
        readonly slotBefore: {
            type: import('vue').PropType<import('vue').VNode | ((option: import('../share').SlotQuery) => import('vue').VNode)>;
        };
        readonly slotAfter: {
            type: import('vue').PropType<import('vue').VNode | ((option: import('../share').SlotQuery) => import('vue').VNode)>;
        };
        readonly fields: {
            readonly type: import('vue').PropType<string[]>;
        };
        readonly backfillToValue: {
            readonly type: import('vue').PropType<(values: string | string[], fields: string | string[], backfill?: Record<string, any>) => string | string[]>;
            readonly default: (v: any) => any;
        };
        readonly options: {
            readonly type: import('vue').PropType<Record<string, any>[]>;
            readonly default: () => never[];
        };
        readonly getOptions: {
            readonly type: import('vue').PropType<import('@xiaohaih/condition-core').GetOptions>;
        };
        readonly field: {
            readonly type: import('vue').PropType<string>;
            readonly required: true;
        };
        readonly query: {
            readonly type: import('vue').PropType<Record<string, any>>;
            readonly required: true;
        };
        readonly backfill: {
            readonly type: import('vue').PropType<Record<string, any>>;
        };
        readonly disabled: {
            readonly type: import('vue').PropType<import('@xiaohaih/condition-core').HideOption>;
        };
        readonly hide: {
            readonly type: import('vue').PropType<import('@xiaohaih/condition-core').HideOption>;
        };
        readonly depend: {
            readonly type: import('vue').PropType<boolean>;
        };
        readonly resetByDependValueChange: {
            readonly type: import('vue').PropType<boolean | ((query: Record<string, any>) => boolean)>;
            readonly default: true;
        };
        readonly dependFields: {
            readonly type: import('vue').PropType<string | string[]>;
        };
        readonly dependWatchOption: {
            readonly type: import('vue').PropType<import('vue').WatchOptions>;
        };
        readonly optionsDepend: {
            readonly type: import('vue').PropType<boolean>;
        };
        readonly optionsDependFields: {
            readonly type: import('vue').PropType<string | string[]>;
        };
        readonly resetToInitialValue: {
            readonly type: import('vue').PropType<boolean>;
        };
        readonly emptyValue: {
            readonly type: import('vue').PropType<undefined | null | boolean | string | number>;
            readonly default: undefined;
        };
        readonly validator: {
            readonly type: import('vue').PropType<((query: Record<string, any>) => any) | ((query: Record<string, any>) => Promise<any>)>;
        };
        readonly customGetQuery: {
            readonly type: import('vue').PropType<import('@xiaohaih/condition-core').GetQuery>;
        };
        readonly defaultValue: {
            readonly type: import('vue').PropType<import('@xiaohaih/condition-core').ValueType | ((query: Record<string, any>, backfill?: Record<string, any>) => import('@xiaohaih/condition-core').ValueType)>;
            readonly default: undefined;
        };
        readonly ariaControls: StringConstructor;
        readonly modelValue: {
            type: (NumberConstructor | StringConstructor | BooleanConstructor)[];
            default: undefined;
        };
        readonly value: {
            type: (ObjectConstructor | NumberConstructor | StringConstructor | BooleanConstructor)[];
            default: undefined;
        };
        readonly indeterminate: BooleanConstructor;
        readonly checked: BooleanConstructor;
        readonly name: {
            type: StringConstructor;
            default: undefined;
        };
        readonly trueValue: {
            type: (NumberConstructor | StringConstructor)[];
            default: undefined;
        };
        readonly falseValue: {
            type: (NumberConstructor | StringConstructor)[];
            default: undefined;
        };
        readonly trueLabel: {
            type: (NumberConstructor | StringConstructor)[];
            default: undefined;
        };
        readonly falseLabel: {
            type: (NumberConstructor | StringConstructor)[];
            default: undefined;
        };
        readonly id: {
            type: StringConstructor;
            default: undefined;
        };
        readonly border: BooleanConstructor;
        readonly size: {
            readonly type: import('vue').PropType<"" | "default" | "small" | "large">;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly tabindex: (NumberConstructor | StringConstructor)[];
        readonly validateEvent: {
            type: BooleanConstructor;
            default: boolean;
        };
    }>> & {}>>>;
    contentProps: import('vue').ComputedRef<Readonly<import('@vue/shared').LooseRequired<Readonly<import('vue').ExtractPropTypes<{
        readonly labelKey: {
            readonly type: import('vue').PropType<string>;
            readonly default: "label";
        };
        readonly valueKey: {
            readonly type: import('vue').PropType<string>;
            readonly default: "value";
        };
        readonly type: {
            readonly type: import('vue').PropType<"checkbox" | "button">;
        };
        readonly multiple: {
            readonly type: import('vue').PropType<boolean>;
            readonly default: true;
        };
        readonly disabledKey: {
            readonly type: import('vue').PropType<string>;
            readonly default: "disabled";
        };
        readonly class: {
            type: import('vue').PropType<string | Record<string, any> | any[]>;
        };
        readonly style: {
            type: import('vue').PropType<string | Record<string, any> | any[]>;
        };
        readonly prop: {
            type: import('vue').PropType<string | string[]>;
        };
        readonly postfix: {
            type: import('vue').PropType<string | import('vue').VNode | ((...args: any[]) => import('vue').VNode)>;
        };
        readonly as: {
            type: import('vue').PropType<string>;
        };
        readonly conditionSortIndex: {
            type: import('vue').PropType<number>;
        };
        readonly dynamicFields: {
            type: import('vue').PropType<(option: {
                query: Record<string, any>;
            }) => Record<string, any> | void>;
        };
        readonly formDynamicFields: {
            type: import('vue').PropType<(option: {
                query: Record<string, any>;
            }) => Record<string, any> | void>;
        };
        readonly slotDefault: {
            type: import('vue').PropType<import('vue').VNode | ((option: import('../share').SlotQuery) => import('vue').VNode)>;
        };
        readonly slotBefore: {
            type: import('vue').PropType<import('vue').VNode | ((option: import('../share').SlotQuery) => import('vue').VNode)>;
        };
        readonly slotAfter: {
            type: import('vue').PropType<import('vue').VNode | ((option: import('../share').SlotQuery) => import('vue').VNode)>;
        };
        readonly fields: {
            readonly type: import('vue').PropType<string[]>;
        };
        readonly backfillToValue: {
            readonly type: import('vue').PropType<(values: string | string[], fields: string | string[], backfill?: Record<string, any>) => string | string[]>;
            readonly default: (v: any) => any;
        };
        readonly options: {
            readonly type: import('vue').PropType<Record<string, any>[]>;
            readonly default: () => never[];
        };
        readonly getOptions: {
            readonly type: import('vue').PropType<import('@xiaohaih/condition-core').GetOptions>;
        };
        readonly field: {
            readonly type: import('vue').PropType<string>;
            readonly required: true;
        };
        readonly query: {
            readonly type: import('vue').PropType<Record<string, any>>;
            readonly required: true;
        };
        readonly backfill: {
            readonly type: import('vue').PropType<Record<string, any>>;
        };
        readonly disabled: {
            readonly type: import('vue').PropType<import('@xiaohaih/condition-core').HideOption>;
        };
        readonly hide: {
            readonly type: import('vue').PropType<import('@xiaohaih/condition-core').HideOption>;
        };
        readonly depend: {
            readonly type: import('vue').PropType<boolean>;
        };
        readonly resetByDependValueChange: {
            readonly type: import('vue').PropType<boolean | ((query: Record<string, any>) => boolean)>;
            readonly default: true;
        };
        readonly dependFields: {
            readonly type: import('vue').PropType<string | string[]>;
        };
        readonly dependWatchOption: {
            readonly type: import('vue').PropType<import('vue').WatchOptions>;
        };
        readonly optionsDepend: {
            readonly type: import('vue').PropType<boolean>;
        };
        readonly optionsDependFields: {
            readonly type: import('vue').PropType<string | string[]>;
        };
        readonly resetToInitialValue: {
            readonly type: import('vue').PropType<boolean>;
        };
        readonly emptyValue: {
            readonly type: import('vue').PropType<undefined | null | boolean | string | number>;
            readonly default: undefined;
        };
        readonly validator: {
            readonly type: import('vue').PropType<((query: Record<string, any>) => any) | ((query: Record<string, any>) => Promise<any>)>;
        };
        readonly customGetQuery: {
            readonly type: import('vue').PropType<import('@xiaohaih/condition-core').GetQuery>;
        };
        readonly defaultValue: {
            readonly type: import('vue').PropType<import('@xiaohaih/condition-core').ValueType | ((query: Record<string, any>, backfill?: Record<string, any>) => import('@xiaohaih/condition-core').ValueType)>;
            readonly default: undefined;
        };
        readonly ariaControls: StringConstructor;
        readonly modelValue: {
            type: (NumberConstructor | StringConstructor | BooleanConstructor)[];
            default: undefined;
        };
        readonly value: {
            type: (ObjectConstructor | NumberConstructor | StringConstructor | BooleanConstructor)[];
            default: undefined;
        };
        readonly indeterminate: BooleanConstructor;
        readonly checked: BooleanConstructor;
        readonly name: {
            type: StringConstructor;
            default: undefined;
        };
        readonly trueValue: {
            type: (NumberConstructor | StringConstructor)[];
            default: undefined;
        };
        readonly falseValue: {
            type: (NumberConstructor | StringConstructor)[];
            default: undefined;
        };
        readonly trueLabel: {
            type: (NumberConstructor | StringConstructor)[];
            default: undefined;
        };
        readonly falseLabel: {
            type: (NumberConstructor | StringConstructor)[];
            default: undefined;
        };
        readonly id: {
            type: StringConstructor;
            default: undefined;
        };
        readonly border: BooleanConstructor;
        readonly size: {
            readonly type: import('vue').PropType<"" | "default" | "small" | "large">;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly tabindex: (NumberConstructor | StringConstructor)[];
        readonly validateEvent: {
            type: BooleanConstructor;
            default: boolean;
        };
    }>> & {}>>>;
    checkboxGroupRef: import('vue').Ref<({
        $: import('vue').ComponentInternalInstance;
        $data: {};
        $props: Partial<{
            readonly disabled: boolean;
            readonly modelValue: import('element-plus').CheckboxGroupValueType;
            readonly validateEvent: boolean;
            readonly tag: string;
        }> & Omit<Readonly<import('vue').ExtractPropTypes<{
            readonly ariaLabel: StringConstructor;
            readonly modelValue: {
                readonly type: import('vue').PropType<import('element-plus').CheckboxGroupValueType>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: () => never[];
            };
            readonly disabled: BooleanConstructor;
            readonly min: NumberConstructor;
            readonly max: NumberConstructor;
            readonly size: {
                readonly type: import('vue').PropType<"" | "default" | "small" | "large">;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly fill: StringConstructor;
            readonly textColor: StringConstructor;
            readonly tag: {
                readonly type: import('vue').PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "div";
            };
            readonly validateEvent: {
                readonly type: import('vue').PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
        }>> & {
            "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxGroupValueType) => any) | undefined;
            onChange?: ((val: import('element-plus').CheckboxValueType[]) => any) | undefined;
        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "disabled" | "modelValue" | "validateEvent" | "tag">;
        $attrs: {
            [x: string]: unknown;
        };
        $refs: {
            [x: string]: unknown;
        };
        $slots: import('vue').Slots;
        $root: import('vue').ComponentPublicInstance | null;
        $parent: import('vue').ComponentPublicInstance | null;
        $emit: ((event: "change", val: import('element-plus').CheckboxValueType[]) => void) & ((event: "update:modelValue", val: import('element-plus').CheckboxGroupValueType) => void);
        $el: any;
        $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
            readonly ariaLabel: StringConstructor;
            readonly modelValue: {
                readonly type: import('vue').PropType<import('element-plus').CheckboxGroupValueType>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: () => never[];
            };
            readonly disabled: BooleanConstructor;
            readonly min: NumberConstructor;
            readonly max: NumberConstructor;
            readonly size: {
                readonly type: import('vue').PropType<"" | "default" | "small" | "large">;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly fill: StringConstructor;
            readonly textColor: StringConstructor;
            readonly tag: {
                readonly type: import('vue').PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "div";
            };
            readonly validateEvent: {
                readonly type: import('vue').PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
        }>> & {
            "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxGroupValueType) => any) | undefined;
            onChange?: ((val: import('element-plus').CheckboxValueType[]) => any) | undefined;
        }, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
            "update:modelValue": (val: import('element-plus').CheckboxGroupValueType) => void;
            change: (val: import('element-plus').CheckboxValueType[]) => void;
        }, string, {
            readonly disabled: boolean;
            readonly modelValue: import('element-plus').CheckboxGroupValueType;
            readonly validateEvent: boolean;
            readonly tag: string;
        }> & {
            beforeCreate?: (() => void) | (() => void)[];
            created?: (() => void) | (() => void)[];
            beforeMount?: (() => void) | (() => void)[];
            mounted?: (() => void) | (() => void)[];
            beforeUpdate?: (() => void) | (() => void)[];
            updated?: (() => void) | (() => void)[];
            activated?: (() => void) | (() => void)[];
            deactivated?: (() => void) | (() => void)[];
            beforeDestroy?: (() => void) | (() => void)[];
            beforeUnmount?: (() => void) | (() => void)[];
            destroyed?: (() => void) | (() => void)[];
            unmounted?: (() => void) | (() => void)[];
            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
        };
        $forceUpdate: () => void;
        $nextTick: typeof import('vue').nextTick;
        $watch(source: string | Function, cb: Function, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
    } & Readonly<import('vue').ExtractPropTypes<{
        readonly ariaLabel: StringConstructor;
        readonly modelValue: {
            readonly type: import('vue').PropType<import('element-plus').CheckboxGroupValueType>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: () => never[];
        };
        readonly disabled: BooleanConstructor;
        readonly min: NumberConstructor;
        readonly max: NumberConstructor;
        readonly size: {
            readonly type: import('vue').PropType<"" | "default" | "small" | "large">;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly fill: StringConstructor;
        readonly textColor: StringConstructor;
        readonly tag: {
            readonly type: import('vue').PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "div";
        };
        readonly validateEvent: {
            readonly type: import('vue').PropType<boolean>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: true;
        };
    }>> & {
        "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxGroupValueType) => any) | undefined;
        onChange?: ((val: import('element-plus').CheckboxValueType[]) => any) | undefined;
    } & import('vue').ShallowUnwrapRef<{}> & {} & import('vue').ComponentCustomProperties & {
        $slots: {
            default?(_: {}): any;
        };
    }) | undefined>;
    checkboxType: import('vue').ComputedRef<"ElCheckboxButton" | "ElCheckbox">;
    getNode: typeof getNode;
    slotProps: import('vue').ComputedRef<{
        disabled: boolean;
        modelValue: (string | number | boolean | Record<string, any> | null | undefined) | (string | number | boolean | Record<string, any> | null | undefined)[];
        'onUpdate:modelValue': (value: (string | number | boolean | Record<string, any> | null | undefined) | (string | number | boolean | Record<string, any> | null | undefined)[]) => void;
        source: Record<string, any>[];
        checkboxType: string;
        valueKey: string;
        labelKey: string;
        class: string;
        extraOption: {
            query: Record<string, any>;
            search: () => Promise<string | void>;
            insetSearch: () => void;
        };
        field: string;
        multiple: boolean;
        query: Record<string, any>;
        backfill: Record<string, any> | undefined;
        hide: import('@xiaohaih/condition-core').HideOption | undefined;
        depend: boolean | undefined;
        resetByDependValueChange: boolean | ((query: Record<string, any>) => boolean);
        dependFields: string | string[] | undefined;
        dependWatchOption: import('vue').WatchOptions<boolean> | undefined;
        optionsDepend: boolean | undefined;
        optionsDependFields: string | string[] | undefined;
        resetToInitialValue: boolean | undefined;
        emptyValue: string | number | boolean | null | undefined;
        validator: ((query: Record<string, any>) => any) | ((query: Record<string, any>) => Promise<any>) | undefined;
        customGetQuery: import('@xiaohaih/condition-core').GetQuery | undefined;
        defaultValue: import('@xiaohaih/condition-core').ValueType | ((query: Record<string, any>, backfill?: Record<string, any>) => import('@xiaohaih/condition-core').ValueType) | undefined;
        type: "button" | "checkbox" | undefined;
        fields: string[] | undefined;
        backfillToValue: (values: string | string[], fields: string | string[], backfill?: Record<string, any>) => string | string[];
        options: Record<string, any>[];
        getOptions: import('@xiaohaih/condition-core').GetOptions | undefined;
        prop: string | string[] | undefined;
        size: ("" | "default" | "small" | "large") | undefined;
        validateEvent: boolean;
        name: string | undefined;
        style: string | any[] | Record<string, any> | undefined;
        postfix: string | import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
            [key: string]: any;
        }> | ((...args: any[]) => import('vue').VNode) | undefined;
        as: string | undefined;
        conditionSortIndex: number | undefined;
        dynamicFields: ((option: {
            query: Record<string, any>;
        }) => Record<string, any> | void) | undefined;
        formDynamicFields: ((option: {
            query: Record<string, any>;
        }) => Record<string, any> | void) | undefined;
        slotDefault: import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
            [key: string]: any;
        }> | ((option: import('../share').SlotQuery) => import('vue').VNode) | undefined;
        slotBefore: import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
            [key: string]: any;
        }> | ((option: import('../share').SlotQuery) => import('vue').VNode) | undefined;
        slotAfter: import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
            [key: string]: any;
        }> | ((option: import('../share').SlotQuery) => import('vue').VNode) | undefined;
        checked: boolean;
        ariaControls: string | undefined;
        value: string | number | boolean | Record<string, any> | undefined;
        indeterminate: boolean;
        trueValue: string | number | undefined;
        falseValue: string | number | undefined;
        trueLabel: string | number | undefined;
        falseLabel: string | number | undefined;
        id: string | undefined;
        border: boolean;
        tabindex: string | number | undefined;
        disabledKey: string;
    }>;
    wrapper: import('@xiaohaih/condition-core').ProvideValue | undefined;
    option: {
        reset(this: void): void;
        resetField(this: void, allowEmptyValue?: boolean): boolean;
        updateWrapperQuery(this: void): void;
        readonly validator: ((query: Record<string, any>) => any) | ((query: Record<string, any>) => Promise<any>) | undefined;
        getQuery: () => Record<string, any>;
        onChangeByBackfill: () => boolean;
    };
    checked: import('vue').Ref<(string | number | boolean | Record<string, any> | null | undefined) | (string | number | boolean | Record<string, any> | null | undefined)[]>;
    getQuery: () => Record<string, any>;
    insetDisabled: import('vue').Ref<boolean>;
    insetHide: import('vue').Ref<boolean>;
    finalOption: import('vue').ComputedRef<Record<string, any>[]>;
    updateCheckedValue: (value: (string | number | boolean | Record<string, any> | null | undefined) | (string | number | boolean | Record<string, any> | null | undefined)[]) => void;
    change: (value: (string | number | boolean | Record<string, any> | null | undefined) | (string | number | boolean | Record<string, any> | null | undefined)[]) => void;
    reset: (this: void) => void;
}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, Readonly<import('vue').ExtractPropTypes<{
    readonly labelKey: {
        readonly type: import('vue').PropType<string>;
        readonly default: "label";
    };
    readonly valueKey: {
        readonly type: import('vue').PropType<string>;
        readonly default: "value";
    };
    readonly type: {
        readonly type: import('vue').PropType<"checkbox" | "button">;
    };
    readonly multiple: {
        readonly type: import('vue').PropType<boolean>;
        readonly default: true;
    };
    readonly disabledKey: {
        readonly type: import('vue').PropType<string>;
        readonly default: "disabled";
    };
    readonly class: {
        type: import('vue').PropType<string | Record<string, any> | any[]>;
    };
    readonly style: {
        type: import('vue').PropType<string | Record<string, any> | any[]>;
    };
    readonly prop: {
        type: import('vue').PropType<string | string[]>;
    };
    readonly postfix: {
        type: import('vue').PropType<string | import('vue').VNode | ((...args: any[]) => import('vue').VNode)>;
    };
    readonly as: {
        type: import('vue').PropType<string>;
    };
    readonly conditionSortIndex: {
        type: import('vue').PropType<number>;
    };
    readonly dynamicFields: {
        type: import('vue').PropType<(option: {
            query: Record<string, any>;
        }) => Record<string, any> | void>;
    };
    readonly formDynamicFields: {
        type: import('vue').PropType<(option: {
            query: Record<string, any>;
        }) => Record<string, any> | void>;
    };
    readonly slotDefault: {
        type: import('vue').PropType<import('vue').VNode | ((option: import('../share').SlotQuery) => import('vue').VNode)>;
    };
    readonly slotBefore: {
        type: import('vue').PropType<import('vue').VNode | ((option: import('../share').SlotQuery) => import('vue').VNode)>;
    };
    readonly slotAfter: {
        type: import('vue').PropType<import('vue').VNode | ((option: import('../share').SlotQuery) => import('vue').VNode)>;
    };
    readonly fields: {
        readonly type: import('vue').PropType<string[]>;
    };
    readonly backfillToValue: {
        readonly type: import('vue').PropType<(values: string | string[], fields: string | string[], backfill?: Record<string, any>) => string | string[]>;
        readonly default: (v: any) => any;
    };
    readonly options: {
        readonly type: import('vue').PropType<Record<string, any>[]>;
        readonly default: () => never[];
    };
    readonly getOptions: {
        readonly type: import('vue').PropType<import('@xiaohaih/condition-core').GetOptions>;
    };
    readonly field: {
        readonly type: import('vue').PropType<string>;
        readonly required: true;
    };
    readonly query: {
        readonly type: import('vue').PropType<Record<string, any>>;
        readonly required: true;
    };
    readonly backfill: {
        readonly type: import('vue').PropType<Record<string, any>>;
    };
    readonly disabled: {
        readonly type: import('vue').PropType<import('@xiaohaih/condition-core').HideOption>;
    };
    readonly hide: {
        readonly type: import('vue').PropType<import('@xiaohaih/condition-core').HideOption>;
    };
    readonly depend: {
        readonly type: import('vue').PropType<boolean>;
    };
    readonly resetByDependValueChange: {
        readonly type: import('vue').PropType<boolean | ((query: Record<string, any>) => boolean)>;
        readonly default: true;
    };
    readonly dependFields: {
        readonly type: import('vue').PropType<string | string[]>;
    };
    readonly dependWatchOption: {
        readonly type: import('vue').PropType<import('vue').WatchOptions>;
    };
    readonly optionsDepend: {
        readonly type: import('vue').PropType<boolean>;
    };
    readonly optionsDependFields: {
        readonly type: import('vue').PropType<string | string[]>;
    };
    readonly resetToInitialValue: {
        readonly type: import('vue').PropType<boolean>;
    };
    readonly emptyValue: {
        readonly type: import('vue').PropType<undefined | null | boolean | string | number>;
        readonly default: undefined;
    };
    readonly validator: {
        readonly type: import('vue').PropType<((query: Record<string, any>) => any) | ((query: Record<string, any>) => Promise<any>)>;
    };
    readonly customGetQuery: {
        readonly type: import('vue').PropType<import('@xiaohaih/condition-core').GetQuery>;
    };
    readonly defaultValue: {
        readonly type: import('vue').PropType<import('@xiaohaih/condition-core').ValueType | ((query: Record<string, any>, backfill?: Record<string, any>) => import('@xiaohaih/condition-core').ValueType)>;
        readonly default: undefined;
    };
    readonly ariaControls: StringConstructor;
    readonly modelValue: {
        type: (NumberConstructor | StringConstructor | BooleanConstructor)[];
        default: undefined;
    };
    readonly value: {
        type: (ObjectConstructor | NumberConstructor | StringConstructor | BooleanConstructor)[];
        default: undefined;
    };
    readonly indeterminate: BooleanConstructor;
    readonly checked: BooleanConstructor;
    readonly name: {
        type: StringConstructor;
        default: undefined;
    };
    readonly trueValue: {
        type: (NumberConstructor | StringConstructor)[];
        default: undefined;
    };
    readonly falseValue: {
        type: (NumberConstructor | StringConstructor)[];
        default: undefined;
    };
    readonly trueLabel: {
        type: (NumberConstructor | StringConstructor)[];
        default: undefined;
    };
    readonly falseLabel: {
        type: (NumberConstructor | StringConstructor)[];
        default: undefined;
    };
    readonly id: {
        type: StringConstructor;
        default: undefined;
    };
    readonly border: BooleanConstructor;
    readonly size: {
        readonly type: import('vue').PropType<"" | "default" | "small" | "large">;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    readonly tabindex: (NumberConstructor | StringConstructor)[];
    readonly validateEvent: {
        type: BooleanConstructor;
        default: boolean;
    };
}>>, {
    readonly multiple: boolean;
    readonly resetByDependValueChange: boolean | ((query: Record<string, any>) => boolean);
    readonly emptyValue: string | number | boolean | null | undefined;
    readonly defaultValue: import('@xiaohaih/condition-core').ValueType | ((query: Record<string, any>, backfill?: Record<string, any>) => import('@xiaohaih/condition-core').ValueType);
    readonly backfillToValue: (values: string | string[], fields: string | string[], backfill?: Record<string, any>) => string | string[];
    readonly options: Record<string, any>[];
    readonly valueKey: string;
    readonly modelValue: string | number | boolean;
    readonly validateEvent: boolean;
    readonly name: string;
    readonly checked: boolean;
    readonly value: string | number | boolean | Record<string, any>;
    readonly indeterminate: boolean;
    readonly trueValue: string | number;
    readonly falseValue: string | number;
    readonly trueLabel: string | number;
    readonly falseLabel: string | number;
    readonly id: string;
    readonly border: boolean;
    readonly labelKey: string;
    readonly disabledKey: string;
}>;
export default _default;