declare const BkSearchSelect: {
    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
        data: {
            type: import("vue").PropType<Omit<import("./utils").ISearchItem, "isSelected" | "value">[]>;
            default: () => any[];
        };
        modelValue: {
            type: import("vue").PropType<import("./utils").ISearchValue[]>;
            default: () => any[];
        };
        maxHeight: {
            type: NumberConstructor;
            default: number;
        };
        conditions: {
            type: import("vue").PropType<import("./utils").ICommonItem[]>;
            default: () => any[];
        };
        clearable: {
            type: BooleanConstructor;
            default: boolean;
        };
        placeholder: StringConstructor;
        getMenuList: import("vue").PropType<import("./utils").GetMenuListFunc>;
        validateValues: import("vue").PropType<import("./utils").ValidateValuesFunc>;
        uniqueSelect: {
            type: BooleanConstructor;
            default: boolean;
        };
        valueBehavior: {
            type: import("vue").PropType<`${import("./utils").ValueBehavior}`>;
            default: import("./utils").ValueBehavior;
            validator(v: import("./utils").ValueBehavior): boolean;
        };
    }>> & Readonly<{
        onCopy?: (...args: any[]) => any;
        onSearch?: (...args: any[]) => any;
        "onUpdate:modelValue"?: (...args: any[]) => any;
        onSelectKey?: (...args: any[]) => any;
    }>, {
        inputRef: import("vue").Ref<import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
            data: {
                type: import("vue").PropType<import("./utils").ISearchItem[]>;
                required: true;
            };
            showInputBefore: BooleanConstructor;
            showCondition: BooleanConstructor;
            clickOutside: FunctionConstructor;
            placeholder: StringConstructor;
            conditions: {
                type: import("vue").PropType<import("./utils").ICommonItem[]>;
                default: () => any[];
            };
            defaultUsingItem: import("vue").PropType<import("./utils").SelectedItem>;
            mode: {
                type: import("vue").PropType<import("./utils").SearchInputMode>;
                default: import("./utils").SearchInputMode;
            };
            maxHeight: {
                type: NumberConstructor;
                default: () => number;
            };
            getMenuList: import("vue").PropType<import("./utils").GetMenuListFunc>;
            validateValues: import("vue").PropType<import("./utils").ValidateValuesFunc>;
            valueBehavior: import("vue").PropType<import("./utils").ValueBehavior>;
        }>> & Readonly<{
            onFocus?: (...args: any[]) => any;
            onAdd?: (...args: any[]) => any;
            onDelete?: (...args: any[]) => any;
            onSelectKey?: (...args: any[]) => any;
        }>, {
            popoverRef: import("vue").Ref<HTMLDivElement, HTMLDivElement>;
            inputRef: import("vue").Ref<HTMLDivElement, HTMLDivElement>;
            keyword: import("vue").Ref<string, string>;
            loading: import("vue").Ref<boolean, boolean>;
            remoteMenuList: import("vue").Ref<{
                id: string;
                name: string;
                disabled?: boolean;
                realId?: string;
                value?: {
                    name: string;
                    id: string;
                    realId?: string;
                    isSelected?: boolean;
                    logical?: import("./utils").SearchLogical;
                };
                isSelected?: boolean;
                logical?: import("./utils").SearchLogical;
            }[], import("./utils").ICommonItem[] | {
                id: string;
                name: string;
                disabled?: boolean;
                realId?: string;
                value?: {
                    name: string;
                    id: string;
                    realId?: string;
                    isSelected?: boolean;
                    logical?: import("./utils").SearchLogical;
                };
                isSelected?: boolean;
                logical?: import("./utils").SearchLogical;
            }[]>;
            menuList: import("vue").Ref<import("./utils").ISearchItem[], import("./utils").ISearchItem[]>;
            menuHoverId: import("vue").Ref<string, string>;
            isFocus: import("vue").Ref<boolean, boolean>;
            isComposition: import("vue").Ref<boolean, boolean>;
            usingItem: import("vue").Ref<import("./utils").SelectedItem, import("./utils").SelectedItem>;
            showPopover: import("vue").Ref<boolean, boolean>;
            showNoSelectValueError: import("vue").Ref<boolean, boolean>;
            debounceSetMenuList: {
                (this: any): any;
                cancel(): void;
            };
            documentArrowEvent: (e: KeyboardEvent) => void;
            handleClickOutside: (e: MouseEvent) => void;
            handleInputFocus: (event?: FocusEvent) => void;
            handleInputChange: (event: Event) => void;
            handleInputPaste: (event: ClipboardEvent) => void;
            handleLogicalChange: (logical: import("./utils").SearchLogical) => void;
            handleInputKeyup: (event: KeyboardEvent) => void;
            handleSelectItem: (item: import("./utils").ICommonItem, type?: import("./utils").SearchItemType) => Promise<void>;
            handleSelectConditionItem: (item: import("./utils").ICommonItem) => void;
            handleMenuFooterClick: (item: import("./utils").IMenuFooterItem) => void;
            resolveClassName: (cls: string) => string;
            inputFocusForWrapper: () => void;
            inputEnterForWrapper: () => Promise<void>;
            inputClearForWrapper: () => void;
            deleteInputTextNode: () => void;
            customPanelSubmit: (value: string) => void;
            refreshMenuHover: () => void;
            t: import("vue").ComputedRef<{
                pleaseSelect: string;
                loading: string;
                filterQueryMustHasValue: string;
                ok: string;
                cancel: string;
                or: string;
                and: string;
                logical: string;
            }>;
            inputKey: import("vue").Ref<string, string>;
            handleCompositionEnd: (event: CompositionEvent) => void;
            handleCompositionStart: () => void;
            handleInputCopy: (event: ClipboardEvent) => void;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "add" | "delete" | "selectKey")[], import("vue").PublicProps, {
            mode: import("./utils").SearchInputMode;
            maxHeight: number;
            conditions: import("./utils").ICommonItem[];
            showInputBefore: boolean;
            showCondition: boolean;
        }, true, {}, import("vue").SlotsType<{
            menu: import("./utils").MenuSlotParams;
        }>, import("vue").GlobalComponents, {
            clickoutside: import("vue").ObjectDirective<any, any, string, any>;
        } & import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("vue").ExtractPropTypes<{
            data: {
                type: import("vue").PropType<import("./utils").ISearchItem[]>;
                required: true;
            };
            showInputBefore: BooleanConstructor;
            showCondition: BooleanConstructor;
            clickOutside: FunctionConstructor;
            placeholder: StringConstructor;
            conditions: {
                type: import("vue").PropType<import("./utils").ICommonItem[]>;
                default: () => any[];
            };
            defaultUsingItem: import("vue").PropType<import("./utils").SelectedItem>;
            mode: {
                type: import("vue").PropType<import("./utils").SearchInputMode>;
                default: import("./utils").SearchInputMode;
            };
            maxHeight: {
                type: NumberConstructor;
                default: () => number;
            };
            getMenuList: import("vue").PropType<import("./utils").GetMenuListFunc>;
            validateValues: import("vue").PropType<import("./utils").ValidateValuesFunc>;
            valueBehavior: import("vue").PropType<import("./utils").ValueBehavior>;
        }>> & Readonly<{
            onFocus?: (...args: any[]) => any;
            onAdd?: (...args: any[]) => any;
            onDelete?: (...args: any[]) => any;
            onSelectKey?: (...args: any[]) => any;
        }>, {
            popoverRef: import("vue").Ref<HTMLDivElement, HTMLDivElement>;
            inputRef: import("vue").Ref<HTMLDivElement, HTMLDivElement>;
            keyword: import("vue").Ref<string, string>;
            loading: import("vue").Ref<boolean, boolean>;
            remoteMenuList: import("vue").Ref<{
                id: string;
                name: string;
                disabled?: boolean;
                realId?: string;
                value?: {
                    name: string;
                    id: string;
                    realId?: string;
                    isSelected?: boolean;
                    logical?: import("./utils").SearchLogical;
                };
                isSelected?: boolean;
                logical?: import("./utils").SearchLogical;
            }[], import("./utils").ICommonItem[] | {
                id: string;
                name: string;
                disabled?: boolean;
                realId?: string;
                value?: {
                    name: string;
                    id: string;
                    realId?: string;
                    isSelected?: boolean;
                    logical?: import("./utils").SearchLogical;
                };
                isSelected?: boolean;
                logical?: import("./utils").SearchLogical;
            }[]>;
            menuList: import("vue").Ref<import("./utils").ISearchItem[], import("./utils").ISearchItem[]>;
            menuHoverId: import("vue").Ref<string, string>;
            isFocus: import("vue").Ref<boolean, boolean>;
            isComposition: import("vue").Ref<boolean, boolean>;
            usingItem: import("vue").Ref<import("./utils").SelectedItem, import("./utils").SelectedItem>;
            showPopover: import("vue").Ref<boolean, boolean>;
            showNoSelectValueError: import("vue").Ref<boolean, boolean>;
            debounceSetMenuList: {
                (this: any): any;
                cancel(): void;
            };
            documentArrowEvent: (e: KeyboardEvent) => void;
            handleClickOutside: (e: MouseEvent) => void;
            handleInputFocus: (event?: FocusEvent) => void;
            handleInputChange: (event: Event) => void;
            handleInputPaste: (event: ClipboardEvent) => void;
            handleLogicalChange: (logical: import("./utils").SearchLogical) => void;
            handleInputKeyup: (event: KeyboardEvent) => void;
            handleSelectItem: (item: import("./utils").ICommonItem, type?: import("./utils").SearchItemType) => Promise<void>;
            handleSelectConditionItem: (item: import("./utils").ICommonItem) => void;
            handleMenuFooterClick: (item: import("./utils").IMenuFooterItem) => void;
            resolveClassName: (cls: string) => string;
            inputFocusForWrapper: () => void;
            inputEnterForWrapper: () => Promise<void>;
            inputClearForWrapper: () => void;
            deleteInputTextNode: () => void;
            customPanelSubmit: (value: string) => void;
            refreshMenuHover: () => void;
            t: import("vue").ComputedRef<{
                pleaseSelect: string;
                loading: string;
                filterQueryMustHasValue: string;
                ok: string;
                cancel: string;
                or: string;
                and: string;
                logical: string;
            }>;
            inputKey: import("vue").Ref<string, string>;
            handleCompositionEnd: (event: CompositionEvent) => void;
            handleCompositionStart: () => void;
            handleInputCopy: (event: ClipboardEvent) => void;
        }, {}, {}, {}, {
            mode: import("./utils").SearchInputMode;
            maxHeight: number;
            conditions: import("./utils").ICommonItem[];
            showInputBefore: boolean;
            showCondition: boolean;
        }>, import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
            data: {
                type: import("vue").PropType<import("./utils").ISearchItem[]>;
                required: true;
            };
            showInputBefore: BooleanConstructor;
            showCondition: BooleanConstructor;
            clickOutside: FunctionConstructor;
            placeholder: StringConstructor;
            conditions: {
                type: import("vue").PropType<import("./utils").ICommonItem[]>;
                default: () => any[];
            };
            defaultUsingItem: import("vue").PropType<import("./utils").SelectedItem>;
            mode: {
                type: import("vue").PropType<import("./utils").SearchInputMode>;
                default: import("./utils").SearchInputMode;
            };
            maxHeight: {
                type: NumberConstructor;
                default: () => number;
            };
            getMenuList: import("vue").PropType<import("./utils").GetMenuListFunc>;
            validateValues: import("vue").PropType<import("./utils").ValidateValuesFunc>;
            valueBehavior: import("vue").PropType<import("./utils").ValueBehavior>;
        }>> & Readonly<{
            onFocus?: (...args: any[]) => any;
            onAdd?: (...args: any[]) => any;
            onDelete?: (...args: any[]) => any;
            onSelectKey?: (...args: any[]) => any;
        }>, {
            popoverRef: import("vue").Ref<HTMLDivElement, HTMLDivElement>;
            inputRef: import("vue").Ref<HTMLDivElement, HTMLDivElement>;
            keyword: import("vue").Ref<string, string>;
            loading: import("vue").Ref<boolean, boolean>;
            remoteMenuList: import("vue").Ref<{
                id: string;
                name: string;
                disabled?: boolean;
                realId?: string;
                value?: {
                    name: string;
                    id: string;
                    realId?: string;
                    isSelected?: boolean;
                    logical?: import("./utils").SearchLogical;
                };
                isSelected?: boolean;
                logical?: import("./utils").SearchLogical;
            }[], import("./utils").ICommonItem[] | {
                id: string;
                name: string;
                disabled?: boolean;
                realId?: string;
                value?: {
                    name: string;
                    id: string;
                    realId?: string;
                    isSelected?: boolean;
                    logical?: import("./utils").SearchLogical;
                };
                isSelected?: boolean;
                logical?: import("./utils").SearchLogical;
            }[]>;
            menuList: import("vue").Ref<import("./utils").ISearchItem[], import("./utils").ISearchItem[]>;
            menuHoverId: import("vue").Ref<string, string>;
            isFocus: import("vue").Ref<boolean, boolean>;
            isComposition: import("vue").Ref<boolean, boolean>;
            usingItem: import("vue").Ref<import("./utils").SelectedItem, import("./utils").SelectedItem>;
            showPopover: import("vue").Ref<boolean, boolean>;
            showNoSelectValueError: import("vue").Ref<boolean, boolean>;
            debounceSetMenuList: {
                (this: any): any;
                cancel(): void;
            };
            documentArrowEvent: (e: KeyboardEvent) => void;
            handleClickOutside: (e: MouseEvent) => void;
            handleInputFocus: (event?: FocusEvent) => void;
            handleInputChange: (event: Event) => void;
            handleInputPaste: (event: ClipboardEvent) => void;
            handleLogicalChange: (logical: import("./utils").SearchLogical) => void;
            handleInputKeyup: (event: KeyboardEvent) => void;
            handleSelectItem: (item: import("./utils").ICommonItem, type?: import("./utils").SearchItemType) => Promise<void>;
            handleSelectConditionItem: (item: import("./utils").ICommonItem) => void;
            handleMenuFooterClick: (item: import("./utils").IMenuFooterItem) => void;
            resolveClassName: (cls: string) => string;
            inputFocusForWrapper: () => void;
            inputEnterForWrapper: () => Promise<void>;
            inputClearForWrapper: () => void;
            deleteInputTextNode: () => void;
            customPanelSubmit: (value: string) => void;
            refreshMenuHover: () => void;
            t: import("vue").ComputedRef<{
                pleaseSelect: string;
                loading: string;
                filterQueryMustHasValue: string;
                ok: string;
                cancel: string;
                or: string;
                and: string;
                logical: string;
            }>;
            inputKey: import("vue").Ref<string, string>;
            handleCompositionEnd: (event: CompositionEvent) => void;
            handleCompositionStart: () => void;
            handleInputCopy: (event: ClipboardEvent) => void;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "add" | "delete" | "selectKey")[], import("vue").PublicProps, {
            mode: import("./utils").SearchInputMode;
            maxHeight: number;
            conditions: import("./utils").ICommonItem[];
            showInputBefore: boolean;
            showCondition: boolean;
        }, true, {}, import("vue").SlotsType<{
            menu: import("./utils").MenuSlotParams;
        }>, import("vue").GlobalComponents, {
            clickoutside: import("vue").ObjectDirective<any, any, string, any>;
        } & import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("vue").ExtractPropTypes<{
            data: {
                type: import("vue").PropType<import("./utils").ISearchItem[]>;
                required: true;
            };
            showInputBefore: BooleanConstructor;
            showCondition: BooleanConstructor;
            clickOutside: FunctionConstructor;
            placeholder: StringConstructor;
            conditions: {
                type: import("vue").PropType<import("./utils").ICommonItem[]>;
                default: () => any[];
            };
            defaultUsingItem: import("vue").PropType<import("./utils").SelectedItem>;
            mode: {
                type: import("vue").PropType<import("./utils").SearchInputMode>;
                default: import("./utils").SearchInputMode;
            };
            maxHeight: {
                type: NumberConstructor;
                default: () => number;
            };
            getMenuList: import("vue").PropType<import("./utils").GetMenuListFunc>;
            validateValues: import("vue").PropType<import("./utils").ValidateValuesFunc>;
            valueBehavior: import("vue").PropType<import("./utils").ValueBehavior>;
        }>> & Readonly<{
            onFocus?: (...args: any[]) => any;
            onAdd?: (...args: any[]) => any;
            onDelete?: (...args: any[]) => any;
            onSelectKey?: (...args: any[]) => any;
        }>, {
            popoverRef: import("vue").Ref<HTMLDivElement, HTMLDivElement>;
            inputRef: import("vue").Ref<HTMLDivElement, HTMLDivElement>;
            keyword: import("vue").Ref<string, string>;
            loading: import("vue").Ref<boolean, boolean>;
            remoteMenuList: import("vue").Ref<{
                id: string;
                name: string;
                disabled?: boolean;
                realId?: string;
                value?: {
                    name: string;
                    id: string;
                    realId?: string;
                    isSelected?: boolean;
                    logical?: import("./utils").SearchLogical;
                };
                isSelected?: boolean;
                logical?: import("./utils").SearchLogical;
            }[], import("./utils").ICommonItem[] | {
                id: string;
                name: string;
                disabled?: boolean;
                realId?: string;
                value?: {
                    name: string;
                    id: string;
                    realId?: string;
                    isSelected?: boolean;
                    logical?: import("./utils").SearchLogical;
                };
                isSelected?: boolean;
                logical?: import("./utils").SearchLogical;
            }[]>;
            menuList: import("vue").Ref<import("./utils").ISearchItem[], import("./utils").ISearchItem[]>;
            menuHoverId: import("vue").Ref<string, string>;
            isFocus: import("vue").Ref<boolean, boolean>;
            isComposition: import("vue").Ref<boolean, boolean>;
            usingItem: import("vue").Ref<import("./utils").SelectedItem, import("./utils").SelectedItem>;
            showPopover: import("vue").Ref<boolean, boolean>;
            showNoSelectValueError: import("vue").Ref<boolean, boolean>;
            debounceSetMenuList: {
                (this: any): any;
                cancel(): void;
            };
            documentArrowEvent: (e: KeyboardEvent) => void;
            handleClickOutside: (e: MouseEvent) => void;
            handleInputFocus: (event?: FocusEvent) => void;
            handleInputChange: (event: Event) => void;
            handleInputPaste: (event: ClipboardEvent) => void;
            handleLogicalChange: (logical: import("./utils").SearchLogical) => void;
            handleInputKeyup: (event: KeyboardEvent) => void;
            handleSelectItem: (item: import("./utils").ICommonItem, type?: import("./utils").SearchItemType) => Promise<void>;
            handleSelectConditionItem: (item: import("./utils").ICommonItem) => void;
            handleMenuFooterClick: (item: import("./utils").IMenuFooterItem) => void;
            resolveClassName: (cls: string) => string;
            inputFocusForWrapper: () => void;
            inputEnterForWrapper: () => Promise<void>;
            inputClearForWrapper: () => void;
            deleteInputTextNode: () => void;
            customPanelSubmit: (value: string) => void;
            refreshMenuHover: () => void;
            t: import("vue").ComputedRef<{
                pleaseSelect: string;
                loading: string;
                filterQueryMustHasValue: string;
                ok: string;
                cancel: string;
                or: string;
                and: string;
                logical: string;
            }>;
            inputKey: import("vue").Ref<string, string>;
            handleCompositionEnd: (event: CompositionEvent) => void;
            handleCompositionStart: () => void;
            handleInputCopy: (event: ClipboardEvent) => void;
        }, {}, {}, {}, {
            mode: import("./utils").SearchInputMode;
            maxHeight: number;
            conditions: import("./utils").ICommonItem[];
            showInputBefore: boolean;
            showCondition: boolean;
        }>>;
        wrapRef: import("vue").Ref<HTMLDivElement, HTMLDivElement>;
        isFocus: import("vue").Ref<boolean, boolean>;
        copyData: import("vue").ShallowRef<import("./utils").ISearchItem[]>;
        selectedList: import("vue").Ref<{
            id: string;
            name: string;
            values: {
                id: string;
                name: string;
                disabled?: boolean;
                realId?: string;
                value?: {
                    name: string;
                    id: string;
                    realId?: string;
                    isSelected?: boolean;
                    logical?: import("./utils").SearchLogical;
                };
                isSelected?: boolean;
                logical?: import("./utils").SearchLogical;
            }[];
            condition: string;
            logical: import("./utils").SearchLogical;
            nameRenderKey: string;
            searchItem: {
                id: string;
                name: string;
                children?: {
                    id: string;
                    name: string;
                    disabled?: boolean;
                    realId?: string;
                    value?: {
                        name: string;
                        id: string;
                        realId?: string;
                        isSelected?: boolean;
                        logical?: import("./utils").SearchLogical;
                    };
                    isSelected?: boolean;
                    logical?: import("./utils").SearchLogical;
                }[];
                multiple?: boolean;
                async?: boolean;
                noValidate?: boolean;
                placeholder?: string;
                disabled?: boolean;
                value?: {
                    id: string;
                    name: string;
                    disabled?: boolean;
                    realId?: string;
                    value?: {
                        name: string;
                        id: string;
                        realId?: string;
                        isSelected?: boolean;
                        logical?: import("./utils").SearchLogical;
                    };
                    isSelected?: boolean;
                    logical?: import("./utils").SearchLogical;
                };
                isSelected?: boolean;
                onlyRecommendChildren?: boolean;
                logical?: import("./utils").SearchLogical;
                showLogicalPanel?: boolean;
                isCustomMenu?: boolean;
            };
            type: import("./utils").SearchItemType;
            readonly multiple: boolean;
            readonly placeholder: string;
            readonly children: {
                id: string;
                name: string;
                disabled?: boolean;
                realId?: string;
                value?: {
                    name: string;
                    id: string;
                    realId?: string;
                    isSelected?: boolean;
                    logical?: import("./utils").SearchLogical;
                };
                isSelected?: boolean;
                logical?: import("./utils").SearchLogical;
            }[];
            readonly validate: boolean;
            readonly inputInnerHtml: string;
            readonly inputInnerText: string;
            readonly keyInnerHtml: string;
            readonly keyInnerText: string;
            readonly showLogical: boolean;
            readonly isCustomMenu: boolean;
            isSpecialType: () => boolean;
            addValue: (item: import("./utils").ICommonItem) => void;
            str2Values: (str: string) => import("./utils").ICommonItem[];
            addValues: (str: string, mergeValues?: boolean) => void;
            getValue: (str: string) => import("./utils").ICommonItem;
            toValue: () => import("./utils").ISearchValue;
            toValueKey: () => string;
            isInValueList: (item: import("./utils").ICommonItem) => boolean;
        }[], import("./utils").SelectedItem[] | {
            id: string;
            name: string;
            values: {
                id: string;
                name: string;
                disabled?: boolean;
                realId?: string;
                value?: {
                    name: string;
                    id: string;
                    realId?: string;
                    isSelected?: boolean;
                    logical?: import("./utils").SearchLogical;
                };
                isSelected?: boolean;
                logical?: import("./utils").SearchLogical;
            }[];
            condition: string;
            logical: import("./utils").SearchLogical;
            nameRenderKey: string;
            searchItem: {
                id: string;
                name: string;
                children?: {
                    id: string;
                    name: string;
                    disabled?: boolean;
                    realId?: string;
                    value?: {
                        name: string;
                        id: string;
                        realId?: string;
                        isSelected?: boolean;
                        logical?: import("./utils").SearchLogical;
                    };
                    isSelected?: boolean;
                    logical?: import("./utils").SearchLogical;
                }[];
                multiple?: boolean;
                async?: boolean;
                noValidate?: boolean;
                placeholder?: string;
                disabled?: boolean;
                value?: {
                    id: string;
                    name: string;
                    disabled?: boolean;
                    realId?: string;
                    value?: {
                        name: string;
                        id: string;
                        realId?: string;
                        isSelected?: boolean;
                        logical?: import("./utils").SearchLogical;
                    };
                    isSelected?: boolean;
                    logical?: import("./utils").SearchLogical;
                };
                isSelected?: boolean;
                onlyRecommendChildren?: boolean;
                logical?: import("./utils").SearchLogical;
                showLogicalPanel?: boolean;
                isCustomMenu?: boolean;
            };
            type: import("./utils").SearchItemType;
            readonly multiple: boolean;
            readonly placeholder: string;
            readonly children: {
                id: string;
                name: string;
                disabled?: boolean;
                realId?: string;
                value?: {
                    name: string;
                    id: string;
                    realId?: string;
                    isSelected?: boolean;
                    logical?: import("./utils").SearchLogical;
                };
                isSelected?: boolean;
                logical?: import("./utils").SearchLogical;
            }[];
            readonly validate: boolean;
            readonly inputInnerHtml: string;
            readonly inputInnerText: string;
            readonly keyInnerHtml: string;
            readonly keyInnerText: string;
            readonly showLogical: boolean;
            readonly isCustomMenu: boolean;
            isSpecialType: () => boolean;
            addValue: (item: import("./utils").ICommonItem) => void;
            str2Values: (str: string) => import("./utils").ICommonItem[];
            addValues: (str: string, mergeValues?: boolean) => void;
            getValue: (str: string) => import("./utils").ICommonItem;
            toValue: () => import("./utils").ISearchValue;
            toValueKey: () => string;
            isInValueList: (item: import("./utils").ICommonItem) => boolean;
        }[]>;
        overflowIndex: import("vue").Ref<number, number>;
        validateStr: import("vue").Ref<string, string>;
        onEditClick: (item: import("./utils").SelectedItem, index: number) => void;
        onEditEnter: (item: import("./utils").SelectedItem, index: number) => void;
        handleWrapClick: () => void;
        handleInputFocus: (v: boolean) => void;
        handleResize: () => void;
        handleClearAll: (e: MouseEvent) => void;
        handleInputOutside: (target: Node) => boolean;
        handleAddSelected: (item: import("./utils").SelectedItem) => void;
        handleDeleteSelected: (index?: number) => void;
        handleClickSearch: (e: MouseEvent) => void;
        localConditions: import("vue").ComputedRef<import("./utils").ICommonItem[]>;
        resolveClassName: (cls: string) => string;
        handleSelectedKey: (a: import("./utils").ICommonItem) => void;
        t: import("vue").ComputedRef<{
            pleaseSelect: string;
            loading: string;
            filterQueryMustHasValue: string;
            ok: string;
            cancel: string;
            or: string;
            and: string;
            logical: string;
        }>;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("search" | "copy" | "update:modelValue" | "selectKey")[], import("vue").PublicProps, {
        data: Omit<import("./utils").ISearchItem, "value" | "isSelected">[];
        maxHeight: number;
        clearable: boolean;
        modelValue: import("./utils").ISearchValue[];
        conditions: import("./utils").ICommonItem[];
        valueBehavior: "all" | "need-key";
        uniqueSelect: boolean;
    }, true, {}, import("vue").SlotsType<{
        menu: import("./utils").MenuSlotParams;
        prepend: () => import("vue").VNode;
        append: () => import("vue").VNode;
        validate: () => import("vue").VNode;
    }>, import("vue").GlobalComponents, {
        clickoutside: import("vue").ObjectDirective<any, any, string, any>;
    } & import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<import("vue").ExtractPropTypes<{
        data: {
            type: import("vue").PropType<Omit<import("./utils").ISearchItem, "isSelected" | "value">[]>;
            default: () => any[];
        };
        modelValue: {
            type: import("vue").PropType<import("./utils").ISearchValue[]>;
            default: () => any[];
        };
        maxHeight: {
            type: NumberConstructor;
            default: number;
        };
        conditions: {
            type: import("vue").PropType<import("./utils").ICommonItem[]>;
            default: () => any[];
        };
        clearable: {
            type: BooleanConstructor;
            default: boolean;
        };
        placeholder: StringConstructor;
        getMenuList: import("vue").PropType<import("./utils").GetMenuListFunc>;
        validateValues: import("vue").PropType<import("./utils").ValidateValuesFunc>;
        uniqueSelect: {
            type: BooleanConstructor;
            default: boolean;
        };
        valueBehavior: {
            type: import("vue").PropType<`${import("./utils").ValueBehavior}`>;
            default: import("./utils").ValueBehavior;
            validator(v: import("./utils").ValueBehavior): boolean;
        };
    }>> & Readonly<{
        onCopy?: (...args: any[]) => any;
        onSearch?: (...args: any[]) => any;
        "onUpdate:modelValue"?: (...args: any[]) => any;
        onSelectKey?: (...args: any[]) => any;
    }>, {
        inputRef: import("vue").Ref<import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
            data: {
                type: import("vue").PropType<import("./utils").ISearchItem[]>;
                required: true;
            };
            showInputBefore: BooleanConstructor;
            showCondition: BooleanConstructor;
            clickOutside: FunctionConstructor;
            placeholder: StringConstructor;
            conditions: {
                type: import("vue").PropType<import("./utils").ICommonItem[]>;
                default: () => any[];
            };
            defaultUsingItem: import("vue").PropType<import("./utils").SelectedItem>;
            mode: {
                type: import("vue").PropType<import("./utils").SearchInputMode>;
                default: import("./utils").SearchInputMode;
            };
            maxHeight: {
                type: NumberConstructor;
                default: () => number;
            };
            getMenuList: import("vue").PropType<import("./utils").GetMenuListFunc>;
            validateValues: import("vue").PropType<import("./utils").ValidateValuesFunc>;
            valueBehavior: import("vue").PropType<import("./utils").ValueBehavior>;
        }>> & Readonly<{
            onFocus?: (...args: any[]) => any;
            onAdd?: (...args: any[]) => any;
            onDelete?: (...args: any[]) => any;
            onSelectKey?: (...args: any[]) => any;
        }>, {
            popoverRef: import("vue").Ref<HTMLDivElement, HTMLDivElement>;
            inputRef: import("vue").Ref<HTMLDivElement, HTMLDivElement>;
            keyword: import("vue").Ref<string, string>;
            loading: import("vue").Ref<boolean, boolean>;
            remoteMenuList: import("vue").Ref<{
                id: string;
                name: string;
                disabled?: boolean;
                realId?: string;
                value?: {
                    name: string;
                    id: string;
                    realId?: string;
                    isSelected?: boolean;
                    logical?: import("./utils").SearchLogical;
                };
                isSelected?: boolean;
                logical?: import("./utils").SearchLogical;
            }[], import("./utils").ICommonItem[] | {
                id: string;
                name: string;
                disabled?: boolean;
                realId?: string;
                value?: {
                    name: string;
                    id: string;
                    realId?: string;
                    isSelected?: boolean;
                    logical?: import("./utils").SearchLogical;
                };
                isSelected?: boolean;
                logical?: import("./utils").SearchLogical;
            }[]>;
            menuList: import("vue").Ref<import("./utils").ISearchItem[], import("./utils").ISearchItem[]>;
            menuHoverId: import("vue").Ref<string, string>;
            isFocus: import("vue").Ref<boolean, boolean>;
            isComposition: import("vue").Ref<boolean, boolean>;
            usingItem: import("vue").Ref<import("./utils").SelectedItem, import("./utils").SelectedItem>;
            showPopover: import("vue").Ref<boolean, boolean>;
            showNoSelectValueError: import("vue").Ref<boolean, boolean>;
            debounceSetMenuList: {
                (this: any): any;
                cancel(): void;
            };
            documentArrowEvent: (e: KeyboardEvent) => void;
            handleClickOutside: (e: MouseEvent) => void;
            handleInputFocus: (event?: FocusEvent) => void;
            handleInputChange: (event: Event) => void;
            handleInputPaste: (event: ClipboardEvent) => void;
            handleLogicalChange: (logical: import("./utils").SearchLogical) => void;
            handleInputKeyup: (event: KeyboardEvent) => void;
            handleSelectItem: (item: import("./utils").ICommonItem, type?: import("./utils").SearchItemType) => Promise<void>;
            handleSelectConditionItem: (item: import("./utils").ICommonItem) => void;
            handleMenuFooterClick: (item: import("./utils").IMenuFooterItem) => void;
            resolveClassName: (cls: string) => string;
            inputFocusForWrapper: () => void;
            inputEnterForWrapper: () => Promise<void>;
            inputClearForWrapper: () => void;
            deleteInputTextNode: () => void;
            customPanelSubmit: (value: string) => void;
            refreshMenuHover: () => void;
            t: import("vue").ComputedRef<{
                pleaseSelect: string;
                loading: string;
                filterQueryMustHasValue: string;
                ok: string;
                cancel: string;
                or: string;
                and: string;
                logical: string;
            }>;
            inputKey: import("vue").Ref<string, string>;
            handleCompositionEnd: (event: CompositionEvent) => void;
            handleCompositionStart: () => void;
            handleInputCopy: (event: ClipboardEvent) => void;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "add" | "delete" | "selectKey")[], import("vue").PublicProps, {
            mode: import("./utils").SearchInputMode;
            maxHeight: number;
            conditions: import("./utils").ICommonItem[];
            showInputBefore: boolean;
            showCondition: boolean;
        }, true, {}, import("vue").SlotsType<{
            menu: import("./utils").MenuSlotParams;
        }>, import("vue").GlobalComponents, {
            clickoutside: import("vue").ObjectDirective<any, any, string, any>;
        } & import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("vue").ExtractPropTypes<{
            data: {
                type: import("vue").PropType<import("./utils").ISearchItem[]>;
                required: true;
            };
            showInputBefore: BooleanConstructor;
            showCondition: BooleanConstructor;
            clickOutside: FunctionConstructor;
            placeholder: StringConstructor;
            conditions: {
                type: import("vue").PropType<import("./utils").ICommonItem[]>;
                default: () => any[];
            };
            defaultUsingItem: import("vue").PropType<import("./utils").SelectedItem>;
            mode: {
                type: import("vue").PropType<import("./utils").SearchInputMode>;
                default: import("./utils").SearchInputMode;
            };
            maxHeight: {
                type: NumberConstructor;
                default: () => number;
            };
            getMenuList: import("vue").PropType<import("./utils").GetMenuListFunc>;
            validateValues: import("vue").PropType<import("./utils").ValidateValuesFunc>;
            valueBehavior: import("vue").PropType<import("./utils").ValueBehavior>;
        }>> & Readonly<{
            onFocus?: (...args: any[]) => any;
            onAdd?: (...args: any[]) => any;
            onDelete?: (...args: any[]) => any;
            onSelectKey?: (...args: any[]) => any;
        }>, {
            popoverRef: import("vue").Ref<HTMLDivElement, HTMLDivElement>;
            inputRef: import("vue").Ref<HTMLDivElement, HTMLDivElement>;
            keyword: import("vue").Ref<string, string>;
            loading: import("vue").Ref<boolean, boolean>;
            remoteMenuList: import("vue").Ref<{
                id: string;
                name: string;
                disabled?: boolean;
                realId?: string;
                value?: {
                    name: string;
                    id: string;
                    realId?: string;
                    isSelected?: boolean;
                    logical?: import("./utils").SearchLogical;
                };
                isSelected?: boolean;
                logical?: import("./utils").SearchLogical;
            }[], import("./utils").ICommonItem[] | {
                id: string;
                name: string;
                disabled?: boolean;
                realId?: string;
                value?: {
                    name: string;
                    id: string;
                    realId?: string;
                    isSelected?: boolean;
                    logical?: import("./utils").SearchLogical;
                };
                isSelected?: boolean;
                logical?: import("./utils").SearchLogical;
            }[]>;
            menuList: import("vue").Ref<import("./utils").ISearchItem[], import("./utils").ISearchItem[]>;
            menuHoverId: import("vue").Ref<string, string>;
            isFocus: import("vue").Ref<boolean, boolean>;
            isComposition: import("vue").Ref<boolean, boolean>;
            usingItem: import("vue").Ref<import("./utils").SelectedItem, import("./utils").SelectedItem>;
            showPopover: import("vue").Ref<boolean, boolean>;
            showNoSelectValueError: import("vue").Ref<boolean, boolean>;
            debounceSetMenuList: {
                (this: any): any;
                cancel(): void;
            };
            documentArrowEvent: (e: KeyboardEvent) => void;
            handleClickOutside: (e: MouseEvent) => void;
            handleInputFocus: (event?: FocusEvent) => void;
            handleInputChange: (event: Event) => void;
            handleInputPaste: (event: ClipboardEvent) => void;
            handleLogicalChange: (logical: import("./utils").SearchLogical) => void;
            handleInputKeyup: (event: KeyboardEvent) => void;
            handleSelectItem: (item: import("./utils").ICommonItem, type?: import("./utils").SearchItemType) => Promise<void>;
            handleSelectConditionItem: (item: import("./utils").ICommonItem) => void;
            handleMenuFooterClick: (item: import("./utils").IMenuFooterItem) => void;
            resolveClassName: (cls: string) => string;
            inputFocusForWrapper: () => void;
            inputEnterForWrapper: () => Promise<void>;
            inputClearForWrapper: () => void;
            deleteInputTextNode: () => void;
            customPanelSubmit: (value: string) => void;
            refreshMenuHover: () => void;
            t: import("vue").ComputedRef<{
                pleaseSelect: string;
                loading: string;
                filterQueryMustHasValue: string;
                ok: string;
                cancel: string;
                or: string;
                and: string;
                logical: string;
            }>;
            inputKey: import("vue").Ref<string, string>;
            handleCompositionEnd: (event: CompositionEvent) => void;
            handleCompositionStart: () => void;
            handleInputCopy: (event: ClipboardEvent) => void;
        }, {}, {}, {}, {
            mode: import("./utils").SearchInputMode;
            maxHeight: number;
            conditions: import("./utils").ICommonItem[];
            showInputBefore: boolean;
            showCondition: boolean;
        }>, import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
            data: {
                type: import("vue").PropType<import("./utils").ISearchItem[]>;
                required: true;
            };
            showInputBefore: BooleanConstructor;
            showCondition: BooleanConstructor;
            clickOutside: FunctionConstructor;
            placeholder: StringConstructor;
            conditions: {
                type: import("vue").PropType<import("./utils").ICommonItem[]>;
                default: () => any[];
            };
            defaultUsingItem: import("vue").PropType<import("./utils").SelectedItem>;
            mode: {
                type: import("vue").PropType<import("./utils").SearchInputMode>;
                default: import("./utils").SearchInputMode;
            };
            maxHeight: {
                type: NumberConstructor;
                default: () => number;
            };
            getMenuList: import("vue").PropType<import("./utils").GetMenuListFunc>;
            validateValues: import("vue").PropType<import("./utils").ValidateValuesFunc>;
            valueBehavior: import("vue").PropType<import("./utils").ValueBehavior>;
        }>> & Readonly<{
            onFocus?: (...args: any[]) => any;
            onAdd?: (...args: any[]) => any;
            onDelete?: (...args: any[]) => any;
            onSelectKey?: (...args: any[]) => any;
        }>, {
            popoverRef: import("vue").Ref<HTMLDivElement, HTMLDivElement>;
            inputRef: import("vue").Ref<HTMLDivElement, HTMLDivElement>;
            keyword: import("vue").Ref<string, string>;
            loading: import("vue").Ref<boolean, boolean>;
            remoteMenuList: import("vue").Ref<{
                id: string;
                name: string;
                disabled?: boolean;
                realId?: string;
                value?: {
                    name: string;
                    id: string;
                    realId?: string;
                    isSelected?: boolean;
                    logical?: import("./utils").SearchLogical;
                };
                isSelected?: boolean;
                logical?: import("./utils").SearchLogical;
            }[], import("./utils").ICommonItem[] | {
                id: string;
                name: string;
                disabled?: boolean;
                realId?: string;
                value?: {
                    name: string;
                    id: string;
                    realId?: string;
                    isSelected?: boolean;
                    logical?: import("./utils").SearchLogical;
                };
                isSelected?: boolean;
                logical?: import("./utils").SearchLogical;
            }[]>;
            menuList: import("vue").Ref<import("./utils").ISearchItem[], import("./utils").ISearchItem[]>;
            menuHoverId: import("vue").Ref<string, string>;
            isFocus: import("vue").Ref<boolean, boolean>;
            isComposition: import("vue").Ref<boolean, boolean>;
            usingItem: import("vue").Ref<import("./utils").SelectedItem, import("./utils").SelectedItem>;
            showPopover: import("vue").Ref<boolean, boolean>;
            showNoSelectValueError: import("vue").Ref<boolean, boolean>;
            debounceSetMenuList: {
                (this: any): any;
                cancel(): void;
            };
            documentArrowEvent: (e: KeyboardEvent) => void;
            handleClickOutside: (e: MouseEvent) => void;
            handleInputFocus: (event?: FocusEvent) => void;
            handleInputChange: (event: Event) => void;
            handleInputPaste: (event: ClipboardEvent) => void;
            handleLogicalChange: (logical: import("./utils").SearchLogical) => void;
            handleInputKeyup: (event: KeyboardEvent) => void;
            handleSelectItem: (item: import("./utils").ICommonItem, type?: import("./utils").SearchItemType) => Promise<void>;
            handleSelectConditionItem: (item: import("./utils").ICommonItem) => void;
            handleMenuFooterClick: (item: import("./utils").IMenuFooterItem) => void;
            resolveClassName: (cls: string) => string;
            inputFocusForWrapper: () => void;
            inputEnterForWrapper: () => Promise<void>;
            inputClearForWrapper: () => void;
            deleteInputTextNode: () => void;
            customPanelSubmit: (value: string) => void;
            refreshMenuHover: () => void;
            t: import("vue").ComputedRef<{
                pleaseSelect: string;
                loading: string;
                filterQueryMustHasValue: string;
                ok: string;
                cancel: string;
                or: string;
                and: string;
                logical: string;
            }>;
            inputKey: import("vue").Ref<string, string>;
            handleCompositionEnd: (event: CompositionEvent) => void;
            handleCompositionStart: () => void;
            handleInputCopy: (event: ClipboardEvent) => void;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "add" | "delete" | "selectKey")[], import("vue").PublicProps, {
            mode: import("./utils").SearchInputMode;
            maxHeight: number;
            conditions: import("./utils").ICommonItem[];
            showInputBefore: boolean;
            showCondition: boolean;
        }, true, {}, import("vue").SlotsType<{
            menu: import("./utils").MenuSlotParams;
        }>, import("vue").GlobalComponents, {
            clickoutside: import("vue").ObjectDirective<any, any, string, any>;
        } & import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("vue").ExtractPropTypes<{
            data: {
                type: import("vue").PropType<import("./utils").ISearchItem[]>;
                required: true;
            };
            showInputBefore: BooleanConstructor;
            showCondition: BooleanConstructor;
            clickOutside: FunctionConstructor;
            placeholder: StringConstructor;
            conditions: {
                type: import("vue").PropType<import("./utils").ICommonItem[]>;
                default: () => any[];
            };
            defaultUsingItem: import("vue").PropType<import("./utils").SelectedItem>;
            mode: {
                type: import("vue").PropType<import("./utils").SearchInputMode>;
                default: import("./utils").SearchInputMode;
            };
            maxHeight: {
                type: NumberConstructor;
                default: () => number;
            };
            getMenuList: import("vue").PropType<import("./utils").GetMenuListFunc>;
            validateValues: import("vue").PropType<import("./utils").ValidateValuesFunc>;
            valueBehavior: import("vue").PropType<import("./utils").ValueBehavior>;
        }>> & Readonly<{
            onFocus?: (...args: any[]) => any;
            onAdd?: (...args: any[]) => any;
            onDelete?: (...args: any[]) => any;
            onSelectKey?: (...args: any[]) => any;
        }>, {
            popoverRef: import("vue").Ref<HTMLDivElement, HTMLDivElement>;
            inputRef: import("vue").Ref<HTMLDivElement, HTMLDivElement>;
            keyword: import("vue").Ref<string, string>;
            loading: import("vue").Ref<boolean, boolean>;
            remoteMenuList: import("vue").Ref<{
                id: string;
                name: string;
                disabled?: boolean;
                realId?: string;
                value?: {
                    name: string;
                    id: string;
                    realId?: string;
                    isSelected?: boolean;
                    logical?: import("./utils").SearchLogical;
                };
                isSelected?: boolean;
                logical?: import("./utils").SearchLogical;
            }[], import("./utils").ICommonItem[] | {
                id: string;
                name: string;
                disabled?: boolean;
                realId?: string;
                value?: {
                    name: string;
                    id: string;
                    realId?: string;
                    isSelected?: boolean;
                    logical?: import("./utils").SearchLogical;
                };
                isSelected?: boolean;
                logical?: import("./utils").SearchLogical;
            }[]>;
            menuList: import("vue").Ref<import("./utils").ISearchItem[], import("./utils").ISearchItem[]>;
            menuHoverId: import("vue").Ref<string, string>;
            isFocus: import("vue").Ref<boolean, boolean>;
            isComposition: import("vue").Ref<boolean, boolean>;
            usingItem: import("vue").Ref<import("./utils").SelectedItem, import("./utils").SelectedItem>;
            showPopover: import("vue").Ref<boolean, boolean>;
            showNoSelectValueError: import("vue").Ref<boolean, boolean>;
            debounceSetMenuList: {
                (this: any): any;
                cancel(): void;
            };
            documentArrowEvent: (e: KeyboardEvent) => void;
            handleClickOutside: (e: MouseEvent) => void;
            handleInputFocus: (event?: FocusEvent) => void;
            handleInputChange: (event: Event) => void;
            handleInputPaste: (event: ClipboardEvent) => void;
            handleLogicalChange: (logical: import("./utils").SearchLogical) => void;
            handleInputKeyup: (event: KeyboardEvent) => void;
            handleSelectItem: (item: import("./utils").ICommonItem, type?: import("./utils").SearchItemType) => Promise<void>;
            handleSelectConditionItem: (item: import("./utils").ICommonItem) => void;
            handleMenuFooterClick: (item: import("./utils").IMenuFooterItem) => void;
            resolveClassName: (cls: string) => string;
            inputFocusForWrapper: () => void;
            inputEnterForWrapper: () => Promise<void>;
            inputClearForWrapper: () => void;
            deleteInputTextNode: () => void;
            customPanelSubmit: (value: string) => void;
            refreshMenuHover: () => void;
            t: import("vue").ComputedRef<{
                pleaseSelect: string;
                loading: string;
                filterQueryMustHasValue: string;
                ok: string;
                cancel: string;
                or: string;
                and: string;
                logical: string;
            }>;
            inputKey: import("vue").Ref<string, string>;
            handleCompositionEnd: (event: CompositionEvent) => void;
            handleCompositionStart: () => void;
            handleInputCopy: (event: ClipboardEvent) => void;
        }, {}, {}, {}, {
            mode: import("./utils").SearchInputMode;
            maxHeight: number;
            conditions: import("./utils").ICommonItem[];
            showInputBefore: boolean;
            showCondition: boolean;
        }>>;
        wrapRef: import("vue").Ref<HTMLDivElement, HTMLDivElement>;
        isFocus: import("vue").Ref<boolean, boolean>;
        copyData: import("vue").ShallowRef<import("./utils").ISearchItem[]>;
        selectedList: import("vue").Ref<{
            id: string;
            name: string;
            values: {
                id: string;
                name: string;
                disabled?: boolean;
                realId?: string;
                value?: {
                    name: string;
                    id: string;
                    realId?: string;
                    isSelected?: boolean;
                    logical?: import("./utils").SearchLogical;
                };
                isSelected?: boolean;
                logical?: import("./utils").SearchLogical;
            }[];
            condition: string;
            logical: import("./utils").SearchLogical;
            nameRenderKey: string;
            searchItem: {
                id: string;
                name: string;
                children?: {
                    id: string;
                    name: string;
                    disabled?: boolean;
                    realId?: string;
                    value?: {
                        name: string;
                        id: string;
                        realId?: string;
                        isSelected?: boolean;
                        logical?: import("./utils").SearchLogical;
                    };
                    isSelected?: boolean;
                    logical?: import("./utils").SearchLogical;
                }[];
                multiple?: boolean;
                async?: boolean;
                noValidate?: boolean;
                placeholder?: string;
                disabled?: boolean;
                value?: {
                    id: string;
                    name: string;
                    disabled?: boolean;
                    realId?: string;
                    value?: {
                        name: string;
                        id: string;
                        realId?: string;
                        isSelected?: boolean;
                        logical?: import("./utils").SearchLogical;
                    };
                    isSelected?: boolean;
                    logical?: import("./utils").SearchLogical;
                };
                isSelected?: boolean;
                onlyRecommendChildren?: boolean;
                logical?: import("./utils").SearchLogical;
                showLogicalPanel?: boolean;
                isCustomMenu?: boolean;
            };
            type: import("./utils").SearchItemType;
            readonly multiple: boolean;
            readonly placeholder: string;
            readonly children: {
                id: string;
                name: string;
                disabled?: boolean;
                realId?: string;
                value?: {
                    name: string;
                    id: string;
                    realId?: string;
                    isSelected?: boolean;
                    logical?: import("./utils").SearchLogical;
                };
                isSelected?: boolean;
                logical?: import("./utils").SearchLogical;
            }[];
            readonly validate: boolean;
            readonly inputInnerHtml: string;
            readonly inputInnerText: string;
            readonly keyInnerHtml: string;
            readonly keyInnerText: string;
            readonly showLogical: boolean;
            readonly isCustomMenu: boolean;
            isSpecialType: () => boolean;
            addValue: (item: import("./utils").ICommonItem) => void;
            str2Values: (str: string) => import("./utils").ICommonItem[];
            addValues: (str: string, mergeValues?: boolean) => void;
            getValue: (str: string) => import("./utils").ICommonItem;
            toValue: () => import("./utils").ISearchValue;
            toValueKey: () => string;
            isInValueList: (item: import("./utils").ICommonItem) => boolean;
        }[], import("./utils").SelectedItem[] | {
            id: string;
            name: string;
            values: {
                id: string;
                name: string;
                disabled?: boolean;
                realId?: string;
                value?: {
                    name: string;
                    id: string;
                    realId?: string;
                    isSelected?: boolean;
                    logical?: import("./utils").SearchLogical;
                };
                isSelected?: boolean;
                logical?: import("./utils").SearchLogical;
            }[];
            condition: string;
            logical: import("./utils").SearchLogical;
            nameRenderKey: string;
            searchItem: {
                id: string;
                name: string;
                children?: {
                    id: string;
                    name: string;
                    disabled?: boolean;
                    realId?: string;
                    value?: {
                        name: string;
                        id: string;
                        realId?: string;
                        isSelected?: boolean;
                        logical?: import("./utils").SearchLogical;
                    };
                    isSelected?: boolean;
                    logical?: import("./utils").SearchLogical;
                }[];
                multiple?: boolean;
                async?: boolean;
                noValidate?: boolean;
                placeholder?: string;
                disabled?: boolean;
                value?: {
                    id: string;
                    name: string;
                    disabled?: boolean;
                    realId?: string;
                    value?: {
                        name: string;
                        id: string;
                        realId?: string;
                        isSelected?: boolean;
                        logical?: import("./utils").SearchLogical;
                    };
                    isSelected?: boolean;
                    logical?: import("./utils").SearchLogical;
                };
                isSelected?: boolean;
                onlyRecommendChildren?: boolean;
                logical?: import("./utils").SearchLogical;
                showLogicalPanel?: boolean;
                isCustomMenu?: boolean;
            };
            type: import("./utils").SearchItemType;
            readonly multiple: boolean;
            readonly placeholder: string;
            readonly children: {
                id: string;
                name: string;
                disabled?: boolean;
                realId?: string;
                value?: {
                    name: string;
                    id: string;
                    realId?: string;
                    isSelected?: boolean;
                    logical?: import("./utils").SearchLogical;
                };
                isSelected?: boolean;
                logical?: import("./utils").SearchLogical;
            }[];
            readonly validate: boolean;
            readonly inputInnerHtml: string;
            readonly inputInnerText: string;
            readonly keyInnerHtml: string;
            readonly keyInnerText: string;
            readonly showLogical: boolean;
            readonly isCustomMenu: boolean;
            isSpecialType: () => boolean;
            addValue: (item: import("./utils").ICommonItem) => void;
            str2Values: (str: string) => import("./utils").ICommonItem[];
            addValues: (str: string, mergeValues?: boolean) => void;
            getValue: (str: string) => import("./utils").ICommonItem;
            toValue: () => import("./utils").ISearchValue;
            toValueKey: () => string;
            isInValueList: (item: import("./utils").ICommonItem) => boolean;
        }[]>;
        overflowIndex: import("vue").Ref<number, number>;
        validateStr: import("vue").Ref<string, string>;
        onEditClick: (item: import("./utils").SelectedItem, index: number) => void;
        onEditEnter: (item: import("./utils").SelectedItem, index: number) => void;
        handleWrapClick: () => void;
        handleInputFocus: (v: boolean) => void;
        handleResize: () => void;
        handleClearAll: (e: MouseEvent) => void;
        handleInputOutside: (target: Node) => boolean;
        handleAddSelected: (item: import("./utils").SelectedItem) => void;
        handleDeleteSelected: (index?: number) => void;
        handleClickSearch: (e: MouseEvent) => void;
        localConditions: import("vue").ComputedRef<import("./utils").ICommonItem[]>;
        resolveClassName: (cls: string) => string;
        handleSelectedKey: (a: import("./utils").ICommonItem) => void;
        t: import("vue").ComputedRef<{
            pleaseSelect: string;
            loading: string;
            filterQueryMustHasValue: string;
            ok: string;
            cancel: string;
            or: string;
            and: string;
            logical: string;
        }>;
    }, {}, {}, {}, {
        data: Omit<import("./utils").ISearchItem, "value" | "isSelected">[];
        maxHeight: number;
        clearable: boolean;
        modelValue: import("./utils").ISearchValue[];
        conditions: import("./utils").ICommonItem[];
        valueBehavior: "all" | "need-key";
        uniqueSelect: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
    data: {
        type: import("vue").PropType<Omit<import("./utils").ISearchItem, "isSelected" | "value">[]>;
        default: () => any[];
    };
    modelValue: {
        type: import("vue").PropType<import("./utils").ISearchValue[]>;
        default: () => any[];
    };
    maxHeight: {
        type: NumberConstructor;
        default: number;
    };
    conditions: {
        type: import("vue").PropType<import("./utils").ICommonItem[]>;
        default: () => any[];
    };
    clearable: {
        type: BooleanConstructor;
        default: boolean;
    };
    placeholder: StringConstructor;
    getMenuList: import("vue").PropType<import("./utils").GetMenuListFunc>;
    validateValues: import("vue").PropType<import("./utils").ValidateValuesFunc>;
    uniqueSelect: {
        type: BooleanConstructor;
        default: boolean;
    };
    valueBehavior: {
        type: import("vue").PropType<`${import("./utils").ValueBehavior}`>;
        default: import("./utils").ValueBehavior;
        validator(v: import("./utils").ValueBehavior): boolean;
    };
}>> & Readonly<{
    onCopy?: (...args: any[]) => any;
    onSearch?: (...args: any[]) => any;
    "onUpdate:modelValue"?: (...args: any[]) => any;
    onSelectKey?: (...args: any[]) => any;
}>, {
    inputRef: import("vue").Ref<import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
        data: {
            type: import("vue").PropType<import("./utils").ISearchItem[]>;
            required: true;
        };
        showInputBefore: BooleanConstructor;
        showCondition: BooleanConstructor;
        clickOutside: FunctionConstructor;
        placeholder: StringConstructor;
        conditions: {
            type: import("vue").PropType<import("./utils").ICommonItem[]>;
            default: () => any[];
        };
        defaultUsingItem: import("vue").PropType<import("./utils").SelectedItem>;
        mode: {
            type: import("vue").PropType<import("./utils").SearchInputMode>;
            default: import("./utils").SearchInputMode;
        };
        maxHeight: {
            type: NumberConstructor;
            default: () => number;
        };
        getMenuList: import("vue").PropType<import("./utils").GetMenuListFunc>;
        validateValues: import("vue").PropType<import("./utils").ValidateValuesFunc>;
        valueBehavior: import("vue").PropType<import("./utils").ValueBehavior>;
    }>> & Readonly<{
        onFocus?: (...args: any[]) => any;
        onAdd?: (...args: any[]) => any;
        onDelete?: (...args: any[]) => any;
        onSelectKey?: (...args: any[]) => any;
    }>, {
        popoverRef: import("vue").Ref<HTMLDivElement, HTMLDivElement>;
        inputRef: import("vue").Ref<HTMLDivElement, HTMLDivElement>;
        keyword: import("vue").Ref<string, string>;
        loading: import("vue").Ref<boolean, boolean>;
        remoteMenuList: import("vue").Ref<{
            id: string;
            name: string;
            disabled?: boolean;
            realId?: string;
            value?: {
                name: string;
                id: string;
                realId?: string;
                isSelected?: boolean;
                logical?: import("./utils").SearchLogical;
            };
            isSelected?: boolean;
            logical?: import("./utils").SearchLogical;
        }[], import("./utils").ICommonItem[] | {
            id: string;
            name: string;
            disabled?: boolean;
            realId?: string;
            value?: {
                name: string;
                id: string;
                realId?: string;
                isSelected?: boolean;
                logical?: import("./utils").SearchLogical;
            };
            isSelected?: boolean;
            logical?: import("./utils").SearchLogical;
        }[]>;
        menuList: import("vue").Ref<import("./utils").ISearchItem[], import("./utils").ISearchItem[]>;
        menuHoverId: import("vue").Ref<string, string>;
        isFocus: import("vue").Ref<boolean, boolean>;
        isComposition: import("vue").Ref<boolean, boolean>;
        usingItem: import("vue").Ref<import("./utils").SelectedItem, import("./utils").SelectedItem>;
        showPopover: import("vue").Ref<boolean, boolean>;
        showNoSelectValueError: import("vue").Ref<boolean, boolean>;
        debounceSetMenuList: {
            (this: any): any;
            cancel(): void;
        };
        documentArrowEvent: (e: KeyboardEvent) => void;
        handleClickOutside: (e: MouseEvent) => void;
        handleInputFocus: (event?: FocusEvent) => void;
        handleInputChange: (event: Event) => void;
        handleInputPaste: (event: ClipboardEvent) => void;
        handleLogicalChange: (logical: import("./utils").SearchLogical) => void;
        handleInputKeyup: (event: KeyboardEvent) => void;
        handleSelectItem: (item: import("./utils").ICommonItem, type?: import("./utils").SearchItemType) => Promise<void>;
        handleSelectConditionItem: (item: import("./utils").ICommonItem) => void;
        handleMenuFooterClick: (item: import("./utils").IMenuFooterItem) => void;
        resolveClassName: (cls: string) => string;
        inputFocusForWrapper: () => void;
        inputEnterForWrapper: () => Promise<void>;
        inputClearForWrapper: () => void;
        deleteInputTextNode: () => void;
        customPanelSubmit: (value: string) => void;
        refreshMenuHover: () => void;
        t: import("vue").ComputedRef<{
            pleaseSelect: string;
            loading: string;
            filterQueryMustHasValue: string;
            ok: string;
            cancel: string;
            or: string;
            and: string;
            logical: string;
        }>;
        inputKey: import("vue").Ref<string, string>;
        handleCompositionEnd: (event: CompositionEvent) => void;
        handleCompositionStart: () => void;
        handleInputCopy: (event: ClipboardEvent) => void;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "add" | "delete" | "selectKey")[], import("vue").PublicProps, {
        mode: import("./utils").SearchInputMode;
        maxHeight: number;
        conditions: import("./utils").ICommonItem[];
        showInputBefore: boolean;
        showCondition: boolean;
    }, true, {}, import("vue").SlotsType<{
        menu: import("./utils").MenuSlotParams;
    }>, import("vue").GlobalComponents, {
        clickoutside: import("vue").ObjectDirective<any, any, string, any>;
    } & import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<import("vue").ExtractPropTypes<{
        data: {
            type: import("vue").PropType<import("./utils").ISearchItem[]>;
            required: true;
        };
        showInputBefore: BooleanConstructor;
        showCondition: BooleanConstructor;
        clickOutside: FunctionConstructor;
        placeholder: StringConstructor;
        conditions: {
            type: import("vue").PropType<import("./utils").ICommonItem[]>;
            default: () => any[];
        };
        defaultUsingItem: import("vue").PropType<import("./utils").SelectedItem>;
        mode: {
            type: import("vue").PropType<import("./utils").SearchInputMode>;
            default: import("./utils").SearchInputMode;
        };
        maxHeight: {
            type: NumberConstructor;
            default: () => number;
        };
        getMenuList: import("vue").PropType<import("./utils").GetMenuListFunc>;
        validateValues: import("vue").PropType<import("./utils").ValidateValuesFunc>;
        valueBehavior: import("vue").PropType<import("./utils").ValueBehavior>;
    }>> & Readonly<{
        onFocus?: (...args: any[]) => any;
        onAdd?: (...args: any[]) => any;
        onDelete?: (...args: any[]) => any;
        onSelectKey?: (...args: any[]) => any;
    }>, {
        popoverRef: import("vue").Ref<HTMLDivElement, HTMLDivElement>;
        inputRef: import("vue").Ref<HTMLDivElement, HTMLDivElement>;
        keyword: import("vue").Ref<string, string>;
        loading: import("vue").Ref<boolean, boolean>;
        remoteMenuList: import("vue").Ref<{
            id: string;
            name: string;
            disabled?: boolean;
            realId?: string;
            value?: {
                name: string;
                id: string;
                realId?: string;
                isSelected?: boolean;
                logical?: import("./utils").SearchLogical;
            };
            isSelected?: boolean;
            logical?: import("./utils").SearchLogical;
        }[], import("./utils").ICommonItem[] | {
            id: string;
            name: string;
            disabled?: boolean;
            realId?: string;
            value?: {
                name: string;
                id: string;
                realId?: string;
                isSelected?: boolean;
                logical?: import("./utils").SearchLogical;
            };
            isSelected?: boolean;
            logical?: import("./utils").SearchLogical;
        }[]>;
        menuList: import("vue").Ref<import("./utils").ISearchItem[], import("./utils").ISearchItem[]>;
        menuHoverId: import("vue").Ref<string, string>;
        isFocus: import("vue").Ref<boolean, boolean>;
        isComposition: import("vue").Ref<boolean, boolean>;
        usingItem: import("vue").Ref<import("./utils").SelectedItem, import("./utils").SelectedItem>;
        showPopover: import("vue").Ref<boolean, boolean>;
        showNoSelectValueError: import("vue").Ref<boolean, boolean>;
        debounceSetMenuList: {
            (this: any): any;
            cancel(): void;
        };
        documentArrowEvent: (e: KeyboardEvent) => void;
        handleClickOutside: (e: MouseEvent) => void;
        handleInputFocus: (event?: FocusEvent) => void;
        handleInputChange: (event: Event) => void;
        handleInputPaste: (event: ClipboardEvent) => void;
        handleLogicalChange: (logical: import("./utils").SearchLogical) => void;
        handleInputKeyup: (event: KeyboardEvent) => void;
        handleSelectItem: (item: import("./utils").ICommonItem, type?: import("./utils").SearchItemType) => Promise<void>;
        handleSelectConditionItem: (item: import("./utils").ICommonItem) => void;
        handleMenuFooterClick: (item: import("./utils").IMenuFooterItem) => void;
        resolveClassName: (cls: string) => string;
        inputFocusForWrapper: () => void;
        inputEnterForWrapper: () => Promise<void>;
        inputClearForWrapper: () => void;
        deleteInputTextNode: () => void;
        customPanelSubmit: (value: string) => void;
        refreshMenuHover: () => void;
        t: import("vue").ComputedRef<{
            pleaseSelect: string;
            loading: string;
            filterQueryMustHasValue: string;
            ok: string;
            cancel: string;
            or: string;
            and: string;
            logical: string;
        }>;
        inputKey: import("vue").Ref<string, string>;
        handleCompositionEnd: (event: CompositionEvent) => void;
        handleCompositionStart: () => void;
        handleInputCopy: (event: ClipboardEvent) => void;
    }, {}, {}, {}, {
        mode: import("./utils").SearchInputMode;
        maxHeight: number;
        conditions: import("./utils").ICommonItem[];
        showInputBefore: boolean;
        showCondition: boolean;
    }>, import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
        data: {
            type: import("vue").PropType<import("./utils").ISearchItem[]>;
            required: true;
        };
        showInputBefore: BooleanConstructor;
        showCondition: BooleanConstructor;
        clickOutside: FunctionConstructor;
        placeholder: StringConstructor;
        conditions: {
            type: import("vue").PropType<import("./utils").ICommonItem[]>;
            default: () => any[];
        };
        defaultUsingItem: import("vue").PropType<import("./utils").SelectedItem>;
        mode: {
            type: import("vue").PropType<import("./utils").SearchInputMode>;
            default: import("./utils").SearchInputMode;
        };
        maxHeight: {
            type: NumberConstructor;
            default: () => number;
        };
        getMenuList: import("vue").PropType<import("./utils").GetMenuListFunc>;
        validateValues: import("vue").PropType<import("./utils").ValidateValuesFunc>;
        valueBehavior: import("vue").PropType<import("./utils").ValueBehavior>;
    }>> & Readonly<{
        onFocus?: (...args: any[]) => any;
        onAdd?: (...args: any[]) => any;
        onDelete?: (...args: any[]) => any;
        onSelectKey?: (...args: any[]) => any;
    }>, {
        popoverRef: import("vue").Ref<HTMLDivElement, HTMLDivElement>;
        inputRef: import("vue").Ref<HTMLDivElement, HTMLDivElement>;
        keyword: import("vue").Ref<string, string>;
        loading: import("vue").Ref<boolean, boolean>;
        remoteMenuList: import("vue").Ref<{
            id: string;
            name: string;
            disabled?: boolean;
            realId?: string;
            value?: {
                name: string;
                id: string;
                realId?: string;
                isSelected?: boolean;
                logical?: import("./utils").SearchLogical;
            };
            isSelected?: boolean;
            logical?: import("./utils").SearchLogical;
        }[], import("./utils").ICommonItem[] | {
            id: string;
            name: string;
            disabled?: boolean;
            realId?: string;
            value?: {
                name: string;
                id: string;
                realId?: string;
                isSelected?: boolean;
                logical?: import("./utils").SearchLogical;
            };
            isSelected?: boolean;
            logical?: import("./utils").SearchLogical;
        }[]>;
        menuList: import("vue").Ref<import("./utils").ISearchItem[], import("./utils").ISearchItem[]>;
        menuHoverId: import("vue").Ref<string, string>;
        isFocus: import("vue").Ref<boolean, boolean>;
        isComposition: import("vue").Ref<boolean, boolean>;
        usingItem: import("vue").Ref<import("./utils").SelectedItem, import("./utils").SelectedItem>;
        showPopover: import("vue").Ref<boolean, boolean>;
        showNoSelectValueError: import("vue").Ref<boolean, boolean>;
        debounceSetMenuList: {
            (this: any): any;
            cancel(): void;
        };
        documentArrowEvent: (e: KeyboardEvent) => void;
        handleClickOutside: (e: MouseEvent) => void;
        handleInputFocus: (event?: FocusEvent) => void;
        handleInputChange: (event: Event) => void;
        handleInputPaste: (event: ClipboardEvent) => void;
        handleLogicalChange: (logical: import("./utils").SearchLogical) => void;
        handleInputKeyup: (event: KeyboardEvent) => void;
        handleSelectItem: (item: import("./utils").ICommonItem, type?: import("./utils").SearchItemType) => Promise<void>;
        handleSelectConditionItem: (item: import("./utils").ICommonItem) => void;
        handleMenuFooterClick: (item: import("./utils").IMenuFooterItem) => void;
        resolveClassName: (cls: string) => string;
        inputFocusForWrapper: () => void;
        inputEnterForWrapper: () => Promise<void>;
        inputClearForWrapper: () => void;
        deleteInputTextNode: () => void;
        customPanelSubmit: (value: string) => void;
        refreshMenuHover: () => void;
        t: import("vue").ComputedRef<{
            pleaseSelect: string;
            loading: string;
            filterQueryMustHasValue: string;
            ok: string;
            cancel: string;
            or: string;
            and: string;
            logical: string;
        }>;
        inputKey: import("vue").Ref<string, string>;
        handleCompositionEnd: (event: CompositionEvent) => void;
        handleCompositionStart: () => void;
        handleInputCopy: (event: ClipboardEvent) => void;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "add" | "delete" | "selectKey")[], import("vue").PublicProps, {
        mode: import("./utils").SearchInputMode;
        maxHeight: number;
        conditions: import("./utils").ICommonItem[];
        showInputBefore: boolean;
        showCondition: boolean;
    }, true, {}, import("vue").SlotsType<{
        menu: import("./utils").MenuSlotParams;
    }>, import("vue").GlobalComponents, {
        clickoutside: import("vue").ObjectDirective<any, any, string, any>;
    } & import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<import("vue").ExtractPropTypes<{
        data: {
            type: import("vue").PropType<import("./utils").ISearchItem[]>;
            required: true;
        };
        showInputBefore: BooleanConstructor;
        showCondition: BooleanConstructor;
        clickOutside: FunctionConstructor;
        placeholder: StringConstructor;
        conditions: {
            type: import("vue").PropType<import("./utils").ICommonItem[]>;
            default: () => any[];
        };
        defaultUsingItem: import("vue").PropType<import("./utils").SelectedItem>;
        mode: {
            type: import("vue").PropType<import("./utils").SearchInputMode>;
            default: import("./utils").SearchInputMode;
        };
        maxHeight: {
            type: NumberConstructor;
            default: () => number;
        };
        getMenuList: import("vue").PropType<import("./utils").GetMenuListFunc>;
        validateValues: import("vue").PropType<import("./utils").ValidateValuesFunc>;
        valueBehavior: import("vue").PropType<import("./utils").ValueBehavior>;
    }>> & Readonly<{
        onFocus?: (...args: any[]) => any;
        onAdd?: (...args: any[]) => any;
        onDelete?: (...args: any[]) => any;
        onSelectKey?: (...args: any[]) => any;
    }>, {
        popoverRef: import("vue").Ref<HTMLDivElement, HTMLDivElement>;
        inputRef: import("vue").Ref<HTMLDivElement, HTMLDivElement>;
        keyword: import("vue").Ref<string, string>;
        loading: import("vue").Ref<boolean, boolean>;
        remoteMenuList: import("vue").Ref<{
            id: string;
            name: string;
            disabled?: boolean;
            realId?: string;
            value?: {
                name: string;
                id: string;
                realId?: string;
                isSelected?: boolean;
                logical?: import("./utils").SearchLogical;
            };
            isSelected?: boolean;
            logical?: import("./utils").SearchLogical;
        }[], import("./utils").ICommonItem[] | {
            id: string;
            name: string;
            disabled?: boolean;
            realId?: string;
            value?: {
                name: string;
                id: string;
                realId?: string;
                isSelected?: boolean;
                logical?: import("./utils").SearchLogical;
            };
            isSelected?: boolean;
            logical?: import("./utils").SearchLogical;
        }[]>;
        menuList: import("vue").Ref<import("./utils").ISearchItem[], import("./utils").ISearchItem[]>;
        menuHoverId: import("vue").Ref<string, string>;
        isFocus: import("vue").Ref<boolean, boolean>;
        isComposition: import("vue").Ref<boolean, boolean>;
        usingItem: import("vue").Ref<import("./utils").SelectedItem, import("./utils").SelectedItem>;
        showPopover: import("vue").Ref<boolean, boolean>;
        showNoSelectValueError: import("vue").Ref<boolean, boolean>;
        debounceSetMenuList: {
            (this: any): any;
            cancel(): void;
        };
        documentArrowEvent: (e: KeyboardEvent) => void;
        handleClickOutside: (e: MouseEvent) => void;
        handleInputFocus: (event?: FocusEvent) => void;
        handleInputChange: (event: Event) => void;
        handleInputPaste: (event: ClipboardEvent) => void;
        handleLogicalChange: (logical: import("./utils").SearchLogical) => void;
        handleInputKeyup: (event: KeyboardEvent) => void;
        handleSelectItem: (item: import("./utils").ICommonItem, type?: import("./utils").SearchItemType) => Promise<void>;
        handleSelectConditionItem: (item: import("./utils").ICommonItem) => void;
        handleMenuFooterClick: (item: import("./utils").IMenuFooterItem) => void;
        resolveClassName: (cls: string) => string;
        inputFocusForWrapper: () => void;
        inputEnterForWrapper: () => Promise<void>;
        inputClearForWrapper: () => void;
        deleteInputTextNode: () => void;
        customPanelSubmit: (value: string) => void;
        refreshMenuHover: () => void;
        t: import("vue").ComputedRef<{
            pleaseSelect: string;
            loading: string;
            filterQueryMustHasValue: string;
            ok: string;
            cancel: string;
            or: string;
            and: string;
            logical: string;
        }>;
        inputKey: import("vue").Ref<string, string>;
        handleCompositionEnd: (event: CompositionEvent) => void;
        handleCompositionStart: () => void;
        handleInputCopy: (event: ClipboardEvent) => void;
    }, {}, {}, {}, {
        mode: import("./utils").SearchInputMode;
        maxHeight: number;
        conditions: import("./utils").ICommonItem[];
        showInputBefore: boolean;
        showCondition: boolean;
    }>>;
    wrapRef: import("vue").Ref<HTMLDivElement, HTMLDivElement>;
    isFocus: import("vue").Ref<boolean, boolean>;
    copyData: import("vue").ShallowRef<import("./utils").ISearchItem[]>;
    selectedList: import("vue").Ref<{
        id: string;
        name: string;
        values: {
            id: string;
            name: string;
            disabled?: boolean;
            realId?: string;
            value?: {
                name: string;
                id: string;
                realId?: string;
                isSelected?: boolean;
                logical?: import("./utils").SearchLogical;
            };
            isSelected?: boolean;
            logical?: import("./utils").SearchLogical;
        }[];
        condition: string;
        logical: import("./utils").SearchLogical;
        nameRenderKey: string;
        searchItem: {
            id: string;
            name: string;
            children?: {
                id: string;
                name: string;
                disabled?: boolean;
                realId?: string;
                value?: {
                    name: string;
                    id: string;
                    realId?: string;
                    isSelected?: boolean;
                    logical?: import("./utils").SearchLogical;
                };
                isSelected?: boolean;
                logical?: import("./utils").SearchLogical;
            }[];
            multiple?: boolean;
            async?: boolean;
            noValidate?: boolean;
            placeholder?: string;
            disabled?: boolean;
            value?: {
                id: string;
                name: string;
                disabled?: boolean;
                realId?: string;
                value?: {
                    name: string;
                    id: string;
                    realId?: string;
                    isSelected?: boolean;
                    logical?: import("./utils").SearchLogical;
                };
                isSelected?: boolean;
                logical?: import("./utils").SearchLogical;
            };
            isSelected?: boolean;
            onlyRecommendChildren?: boolean;
            logical?: import("./utils").SearchLogical;
            showLogicalPanel?: boolean;
            isCustomMenu?: boolean;
        };
        type: import("./utils").SearchItemType;
        readonly multiple: boolean;
        readonly placeholder: string;
        readonly children: {
            id: string;
            name: string;
            disabled?: boolean;
            realId?: string;
            value?: {
                name: string;
                id: string;
                realId?: string;
                isSelected?: boolean;
                logical?: import("./utils").SearchLogical;
            };
            isSelected?: boolean;
            logical?: import("./utils").SearchLogical;
        }[];
        readonly validate: boolean;
        readonly inputInnerHtml: string;
        readonly inputInnerText: string;
        readonly keyInnerHtml: string;
        readonly keyInnerText: string;
        readonly showLogical: boolean;
        readonly isCustomMenu: boolean;
        isSpecialType: () => boolean;
        addValue: (item: import("./utils").ICommonItem) => void;
        str2Values: (str: string) => import("./utils").ICommonItem[];
        addValues: (str: string, mergeValues?: boolean) => void;
        getValue: (str: string) => import("./utils").ICommonItem;
        toValue: () => import("./utils").ISearchValue;
        toValueKey: () => string;
        isInValueList: (item: import("./utils").ICommonItem) => boolean;
    }[], import("./utils").SelectedItem[] | {
        id: string;
        name: string;
        values: {
            id: string;
            name: string;
            disabled?: boolean;
            realId?: string;
            value?: {
                name: string;
                id: string;
                realId?: string;
                isSelected?: boolean;
                logical?: import("./utils").SearchLogical;
            };
            isSelected?: boolean;
            logical?: import("./utils").SearchLogical;
        }[];
        condition: string;
        logical: import("./utils").SearchLogical;
        nameRenderKey: string;
        searchItem: {
            id: string;
            name: string;
            children?: {
                id: string;
                name: string;
                disabled?: boolean;
                realId?: string;
                value?: {
                    name: string;
                    id: string;
                    realId?: string;
                    isSelected?: boolean;
                    logical?: import("./utils").SearchLogical;
                };
                isSelected?: boolean;
                logical?: import("./utils").SearchLogical;
            }[];
            multiple?: boolean;
            async?: boolean;
            noValidate?: boolean;
            placeholder?: string;
            disabled?: boolean;
            value?: {
                id: string;
                name: string;
                disabled?: boolean;
                realId?: string;
                value?: {
                    name: string;
                    id: string;
                    realId?: string;
                    isSelected?: boolean;
                    logical?: import("./utils").SearchLogical;
                };
                isSelected?: boolean;
                logical?: import("./utils").SearchLogical;
            };
            isSelected?: boolean;
            onlyRecommendChildren?: boolean;
            logical?: import("./utils").SearchLogical;
            showLogicalPanel?: boolean;
            isCustomMenu?: boolean;
        };
        type: import("./utils").SearchItemType;
        readonly multiple: boolean;
        readonly placeholder: string;
        readonly children: {
            id: string;
            name: string;
            disabled?: boolean;
            realId?: string;
            value?: {
                name: string;
                id: string;
                realId?: string;
                isSelected?: boolean;
                logical?: import("./utils").SearchLogical;
            };
            isSelected?: boolean;
            logical?: import("./utils").SearchLogical;
        }[];
        readonly validate: boolean;
        readonly inputInnerHtml: string;
        readonly inputInnerText: string;
        readonly keyInnerHtml: string;
        readonly keyInnerText: string;
        readonly showLogical: boolean;
        readonly isCustomMenu: boolean;
        isSpecialType: () => boolean;
        addValue: (item: import("./utils").ICommonItem) => void;
        str2Values: (str: string) => import("./utils").ICommonItem[];
        addValues: (str: string, mergeValues?: boolean) => void;
        getValue: (str: string) => import("./utils").ICommonItem;
        toValue: () => import("./utils").ISearchValue;
        toValueKey: () => string;
        isInValueList: (item: import("./utils").ICommonItem) => boolean;
    }[]>;
    overflowIndex: import("vue").Ref<number, number>;
    validateStr: import("vue").Ref<string, string>;
    onEditClick: (item: import("./utils").SelectedItem, index: number) => void;
    onEditEnter: (item: import("./utils").SelectedItem, index: number) => void;
    handleWrapClick: () => void;
    handleInputFocus: (v: boolean) => void;
    handleResize: () => void;
    handleClearAll: (e: MouseEvent) => void;
    handleInputOutside: (target: Node) => boolean;
    handleAddSelected: (item: import("./utils").SelectedItem) => void;
    handleDeleteSelected: (index?: number) => void;
    handleClickSearch: (e: MouseEvent) => void;
    localConditions: import("vue").ComputedRef<import("./utils").ICommonItem[]>;
    resolveClassName: (cls: string) => string;
    handleSelectedKey: (a: import("./utils").ICommonItem) => void;
    t: import("vue").ComputedRef<{
        pleaseSelect: string;
        loading: string;
        filterQueryMustHasValue: string;
        ok: string;
        cancel: string;
        or: string;
        and: string;
        logical: string;
    }>;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("search" | "copy" | "update:modelValue" | "selectKey")[], "search" | "copy" | "update:modelValue" | "selectKey", {
    data: Omit<import("./utils").ISearchItem, "value" | "isSelected">[];
    maxHeight: number;
    clearable: boolean;
    modelValue: import("./utils").ISearchValue[];
    conditions: import("./utils").ICommonItem[];
    valueBehavior: "all" | "need-key";
    uniqueSelect: boolean;
}, {}, string, import("vue").SlotsType<{
    menu: import("./utils").MenuSlotParams;
    prepend: () => import("vue").VNode;
    append: () => import("vue").VNode;
    validate: () => import("vue").VNode;
}>, import("vue").GlobalComponents, {
    clickoutside: import("vue").ObjectDirective<any, any, string, any>;
} & import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("vue").Plugin;
export default BkSearchSelect;
export { BkSearchSelect };
