@opendesign-plus-test/components 0.0.1-rc.220 → 0.0.1-rc.221

package/dist/treeshaking/components/search-result/OSearchResultHeader.vue.d.ts

@@ -0,0 +1,1296 @@
+import { OSearchItemT } from './types';
+import { OSearchPayload } from '../search/types';
+import { OSearchInputPropsT } from '../search/OSearchInput.vue';
+type __VLS_Props = {
+    bg?: string;
+    tabs?: OSearchItemT[];
+    inputProps?: OSearchInputPropsT;
+};
+type __VLS_PublicProps = {
+    'searchInput'?: string;
+    'tab'?: string | number;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        input?(_: {}): any;
+        tab?(_: {}): any;
+    };
+    refs: {
+        searchInputRef: ({
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly [x: `on${Capitalize<any>}`]: ((...args: any) => any) | undefined;
+                readonly modelValue?: string | undefined;
+                readonly imageUrl?: string | undefined;
+                readonly size?: "small" | "medium" | "large" | undefined;
+                readonly placeholder?: string | undefined;
+                readonly imagePlaceholder?: string | undefined;
+                readonly enableImageSearch?: boolean | undefined;
+                readonly uploadImage?: import('../search').OSearchUploadImageFn | undefined;
+                readonly maxImageSize?: number | undefined;
+                readonly imageUploadTooltip?: string | undefined;
+                readonly allowedImageTypes?: string[] | undefined;
+                readonly suggestItems?: import('../search').OSearchRecommendItem[] | undefined;
+                readonly onestepItems?: import('../search').OSearchRecommendItem[] | undefined;
+                readonly suggestTitle?: string | undefined;
+                readonly onestepTitle?: string | undefined;
+                readonly noDataText?: string | undefined;
+                readonly showSuggestEmpty?: boolean | undefined;
+                readonly highlightKeyword?: boolean | undefined;
+                readonly debounce?: number | undefined;
+                readonly enableHistory?: boolean | undefined;
+                readonly historyItems?: string[] | undefined;
+                readonly maxHistoryCount?: number | undefined;
+                readonly storeHistory?: boolean | undefined;
+                readonly storageKey?: string | undefined;
+                readonly historyTitle?: string | undefined;
+                readonly autoSaveHistory?: boolean | undefined;
+                readonly hotItems?: string[] | undefined;
+                readonly hotTitle?: string | undefined;
+                readonly suggestList?: string[] | undefined;
+                readonly suggestListLabel?: string | undefined;
+                readonly clearable?: boolean | undefined;
+                readonly closeOnSearch?: boolean | undefined;
+                readonly closeOnClickOutside?: boolean | undefined;
+                readonly openOnFocus?: boolean | undefined;
+                readonly alwaysInlineThumbnail?: boolean | undefined;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+            $attrs: import('vue').Attrs;
+            $refs: {
+                [x: string]: unknown;
+            } & {
+                wrapperRef: HTMLDivElement;
+                inputRef: ({
+                    $: import('vue').ComponentInternalInstance;
+                    $data: {};
+                    $props: {
+                        readonly [x: `on${Capitalize<any>}`]: ((...args: any) => any) | undefined;
+                        readonly modelValue?: string | undefined;
+                        readonly imageUrl?: string | undefined;
+                        readonly placeholder?: string | undefined;
+                        readonly imagePlaceholder?: string | undefined;
+                        readonly size?: "small" | "medium" | "large" | undefined;
+                        readonly enableImageSearch?: boolean | undefined;
+                        readonly uploadImage?: import('../search').OSearchUploadImageFn | undefined;
+                        readonly maxImageSize?: number | undefined;
+                        readonly imageUploadTooltip?: string | undefined;
+                        readonly expanded?: boolean | undefined;
+                        readonly clearable?: boolean | undefined;
+                        readonly showSuffix?: boolean | undefined;
+                        readonly inlineThumbnail?: boolean | undefined;
+                        readonly preview?: boolean | undefined;
+                        readonly disabled?: boolean | undefined;
+                        readonly allowedImageTypes?: string[] | undefined;
+                    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+                    $attrs: import('vue').Attrs;
+                    $refs: {
+                        [x: string]: unknown;
+                    } & {
+                        inputRef: ({
+                            $: import('vue').ComponentInternalInstance;
+                            $data: {};
+                            $props: Partial<{
+                                color: "normal" | "primary" | "success" | "warning" | "danger";
+                                type: "text" | "password";
+                                disabled: boolean | undefined;
+                                variant: "solid" | "outline" | "text";
+                                clearable: boolean | undefined;
+                                readonly: boolean;
+                                noKeyboard: boolean;
+                                showLength: "auto" | "always" | "never";
+                                inputOnOutlimit: boolean;
+                                showPasswordEvent: "click" | "pointerdown";
+                                autoWidth: boolean;
+                                passwordPlaceholder: string;
+                                onlyNumericInput: boolean;
+                            }> & Omit<{
+                                readonly type: "text" | "password";
+                                readonly color: "danger" | "warning" | "success" | "primary" | "normal";
+                                readonly variant: "solid" | "outline" | "text";
+                                readonly readonly: boolean;
+                                readonly noKeyboard: boolean;
+                                readonly showLength: "auto" | "always" | "never";
+                                readonly inputOnOutlimit: boolean;
+                                readonly showPasswordEvent: "click" | "pointerdown";
+                                readonly autoWidth: boolean;
+                                readonly passwordPlaceholder: string;
+                                readonly onlyNumericInput: boolean;
+                                readonly size?: "small" | "large" | "medium" | undefined;
+                                readonly round?: import('@opensig/opendesign').RoundT | undefined;
+                                readonly disabled?: boolean | undefined;
+                                readonly clearable?: boolean | undefined;
+                                readonly modelValue?: string | number | undefined;
+                                readonly defaultValue?: string | number | undefined;
+                                readonly placeholder?: string | undefined;
+                                readonly inputId?: string | undefined;
+                                readonly minLength?: number | undefined;
+                                readonly maxLength?: number | undefined;
+                                readonly getLength?: ((val: string) => number) | undefined;
+                                readonly format?: ((value: string) => string) | undefined;
+                                readonly validate?: ((value: string) => boolean) | undefined;
+                                readonly valueOnInvalidChange?: boolean | ((inputValue: string, lastValidInputValue: string) => string) | undefined;
+                                readonly onInput?: ((evt: Event, value: string) => any) | undefined | undefined;
+                                readonly onClear?: ((evt?: Event | undefined) => any) | undefined | undefined;
+                                readonly onBlur?: ((evt: FocusEvent) => any) | undefined | undefined;
+                                readonly onChange?: ((value: string) => any) | undefined | undefined;
+                                readonly onFocus?: ((evt: FocusEvent) => any) | undefined | undefined;
+                                readonly "onUpdate:modelValue"?: ((value: string) => any) | undefined | undefined;
+                                readonly onPressEnter?: ((evt: KeyboardEvent) => any) | undefined | undefined;
+                            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "type" | "color" | "variant" | "disabled" | "clearable" | "readonly" | "noKeyboard" | "showLength" | "inputOnOutlimit" | "showPasswordEvent" | "autoWidth" | "passwordPlaceholder" | "onlyNumericInput">;
+                            $attrs: import('vue').Attrs;
+                            $refs: {
+                                [x: string]: unknown;
+                            };
+                            $slots: Readonly<{
+                                [name: string]: import('vue').Slot<any> | undefined;
+                            }>;
+                            $root: import('vue').ComponentPublicInstance | null;
+                            $parent: import('vue').ComponentPublicInstance | null;
+                            $host: Element | null;
+                            $emit: ((event: "change", value: string) => void) & ((event: "input", evt: Event, value: string) => void) & ((event: "blur", evt: FocusEvent) => void) & ((event: "focus", evt: FocusEvent) => void) & ((event: "clear", evt?: Event | undefined) => void) & ((event: "update:modelValue", value: string) => void) & ((event: "pressEnter", evt: KeyboardEvent) => void);
+                            $el: any;
+                            $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+                                size: {
+                                    type: import('vue').PropType<import('@opensig/opendesign').SizeT>;
+                                };
+                                round: {
+                                    type: import('vue').PropType<import('@opensig/opendesign').RoundT>;
+                                };
+                                color: {
+                                    type: import('vue').PropType<import('@opensig/opendesign').Color2T>;
+                                    default: string;
+                                };
+                                variant: {
+                                    type: import('vue').PropType<import('@opensig/opendesign').VariantT>;
+                                    default: string;
+                                };
+                                modelValue: {
+                                    type: (NumberConstructor | StringConstructor)[];
+                                };
+                                defaultValue: {
+                                    type: (NumberConstructor | StringConstructor)[];
+                                };
+                                type: {
+                                    type: import('vue').PropType<"text" | "password">;
+                                    default: string;
+                                };
+                                placeholder: {
+                                    type: StringConstructor;
+                                };
+                                inputId: {
+                                    type: StringConstructor;
+                                };
+                                disabled: {
+                                    type: import('vue').PropType<boolean | undefined>;
+                                    default: undefined;
+                                };
+                                readonly: {
+                                    type: BooleanConstructor;
+                                };
+                                noKeyboard: {
+                                    type: BooleanConstructor;
+                                };
+                                clearable: {
+                                    type: import('vue').PropType<boolean | undefined>;
+                                    default: undefined;
+                                };
+                                minLength: {
+                                    type: NumberConstructor;
+                                };
+                                maxLength: {
+                                    type: NumberConstructor;
+                                };
+                                showLength: {
+                                    type: import('vue').PropType<"always" | "auto" | "never">;
+                                    default: string;
+                                };
+                                getLength: {
+                                    type: import('vue').PropType<(val: string) => number>;
+                                };
+                                inputOnOutlimit: {
+                                    type: BooleanConstructor;
+                                    default: boolean;
+                                };
+                                format: {
+                                    type: import('vue').PropType<(value: string) => string>;
+                                };
+                                validate: {
+                                    type: import('vue').PropType<(value: string) => boolean>;
+                                };
+                                valueOnInvalidChange: {
+                                    type: import('vue').PropType<boolean | ((inputValue: string, lastValidInputValue: string) => string)>;
+                                };
+                                showPasswordEvent: {
+                                    type: import('vue').PropType<"click" | "pointerdown">;
+                                    default: string;
+                                };
+                                autoWidth: {
+                                    type: BooleanConstructor;
+                                };
+                                passwordPlaceholder: {
+                                    type: StringConstructor;
+                                    default: string;
+                                };
+                                onlyNumericInput: {
+                                    type: BooleanConstructor;
+                                };
+                            }>> & Readonly<{
+                                onInput?: ((evt: Event, value: string) => any) | undefined;
+                                onClear?: ((evt?: Event | undefined) => any) | undefined;
+                                onBlur?: ((evt: FocusEvent) => any) | undefined;
+                                onChange?: ((value: string) => any) | undefined;
+                                onFocus?: ((evt: FocusEvent) => any) | undefined;
+                                "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+                                onPressEnter?: ((evt: KeyboardEvent) => any) | undefined;
+                            }>, {
+                                focus: () => void | undefined;
+                                blur: () => void | undefined;
+                                clear: () => void | undefined;
+                                inputEl: () => HTMLInputElement | HTMLTextAreaElement | undefined;
+                                togglePassword: () => void | undefined;
+                            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                                input: (evt: Event, value: string) => any;
+                                clear: (evt?: Event | undefined) => any;
+                                blur: (evt: FocusEvent) => any;
+                                change: (value: string) => any;
+                                focus: (evt: FocusEvent) => any;
+                                "update:modelValue": (value: string) => any;
+                                pressEnter: (evt: KeyboardEvent) => any;
+                            }, string, {
+                                color: "normal" | "primary" | "success" | "warning" | "danger";
+                                type: "text" | "password";
+                                disabled: boolean | undefined;
+                                variant: "solid" | "outline" | "text";
+                                clearable: boolean | undefined;
+                                readonly: boolean;
+                                noKeyboard: boolean;
+                                showLength: "auto" | "always" | "never";
+                                inputOnOutlimit: boolean;
+                                showPasswordEvent: "click" | "pointerdown";
+                                autoWidth: boolean;
+                                passwordPlaceholder: string;
+                                onlyNumericInput: boolean;
+                            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                                beforeCreate?: (() => void) | (() => void)[];
+                                created?: (() => void) | (() => void)[];
+                                beforeMount?: (() => void) | (() => void)[];
+                                mounted?: (() => void) | (() => void)[];
+                                beforeUpdate?: (() => void) | (() => void)[];
+                                updated?: (() => void) | (() => void)[];
+                                activated?: (() => void) | (() => void)[];
+                                deactivated?: (() => void) | (() => void)[];
+                                beforeDestroy?: (() => void) | (() => void)[];
+                                beforeUnmount?: (() => void) | (() => void)[];
+                                destroyed?: (() => void) | (() => void)[];
+                                unmounted?: (() => void) | (() => void)[];
+                                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                                errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+                            };
+                            $forceUpdate: () => void;
+                            $nextTick: typeof import('vue').nextTick;
+                            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+                        } & Readonly<{
+                            color: "normal" | "primary" | "success" | "warning" | "danger";
+                            type: "text" | "password";
+                            disabled: boolean | undefined;
+                            variant: "solid" | "outline" | "text";
+                            clearable: boolean | undefined;
+                            readonly: boolean;
+                            noKeyboard: boolean;
+                            showLength: "auto" | "always" | "never";
+                            inputOnOutlimit: boolean;
+                            showPasswordEvent: "click" | "pointerdown";
+                            autoWidth: boolean;
+                            passwordPlaceholder: string;
+                            onlyNumericInput: boolean;
+                        }> & Omit<Readonly<import('vue').ExtractPropTypes<{
+                            size: {
+                                type: import('vue').PropType<import('@opensig/opendesign').SizeT>;
+                            };
+                            round: {
+                                type: import('vue').PropType<import('@opensig/opendesign').RoundT>;
+                            };
+                            color: {
+                                type: import('vue').PropType<import('@opensig/opendesign').Color2T>;
+                                default: string;
+                            };
+                            variant: {
+                                type: import('vue').PropType<import('@opensig/opendesign').VariantT>;
+                                default: string;
+                            };
+                            modelValue: {
+                                type: (NumberConstructor | StringConstructor)[];
+                            };
+                            defaultValue: {
+                                type: (NumberConstructor | StringConstructor)[];
+                            };
+                            type: {
+                                type: import('vue').PropType<"text" | "password">;
+                                default: string;
+                            };
+                            placeholder: {
+                                type: StringConstructor;
+                            };
+                            inputId: {
+                                type: StringConstructor;
+                            };
+                            disabled: {
+                                type: import('vue').PropType<boolean | undefined>;
+                                default: undefined;
+                            };
+                            readonly: {
+                                type: BooleanConstructor;
+                            };
+                            noKeyboard: {
+                                type: BooleanConstructor;
+                            };
+                            clearable: {
+                                type: import('vue').PropType<boolean | undefined>;
+                                default: undefined;
+                            };
+                            minLength: {
+                                type: NumberConstructor;
+                            };
+                            maxLength: {
+                                type: NumberConstructor;
+                            };
+                            showLength: {
+                                type: import('vue').PropType<"always" | "auto" | "never">;
+                                default: string;
+                            };
+                            getLength: {
+                                type: import('vue').PropType<(val: string) => number>;
+                            };
+                            inputOnOutlimit: {
+                                type: BooleanConstructor;
+                                default: boolean;
+                            };
+                            format: {
+                                type: import('vue').PropType<(value: string) => string>;
+                            };
+                            validate: {
+                                type: import('vue').PropType<(value: string) => boolean>;
+                            };
+                            valueOnInvalidChange: {
+                                type: import('vue').PropType<boolean | ((inputValue: string, lastValidInputValue: string) => string)>;
+                            };
+                            showPasswordEvent: {
+                                type: import('vue').PropType<"click" | "pointerdown">;
+                                default: string;
+                            };
+                            autoWidth: {
+                                type: BooleanConstructor;
+                            };
+                            passwordPlaceholder: {
+                                type: StringConstructor;
+                                default: string;
+                            };
+                            onlyNumericInput: {
+                                type: BooleanConstructor;
+                            };
+                        }>> & Readonly<{
+                            onInput?: ((evt: Event, value: string) => any) | undefined;
+                            onClear?: ((evt?: Event | undefined) => any) | undefined;
+                            onBlur?: ((evt: FocusEvent) => any) | undefined;
+                            onChange?: ((value: string) => any) | undefined;
+                            onFocus?: ((evt: FocusEvent) => any) | undefined;
+                            "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+                            onPressEnter?: ((evt: KeyboardEvent) => any) | undefined;
+                        }>, "blur" | "focus" | "type" | "color" | "variant" | "disabled" | "clear" | "clearable" | "readonly" | "noKeyboard" | "showLength" | "inputOnOutlimit" | "showPasswordEvent" | "autoWidth" | "passwordPlaceholder" | "onlyNumericInput" | "inputEl" | "togglePassword"> & {
+                            focus: () => void | undefined;
+                            blur: () => void | undefined;
+                            clear: () => void | undefined;
+                            inputEl: () => HTMLInputElement | HTMLTextAreaElement | undefined;
+                            togglePassword: () => void | undefined;
+                        } & {} & import('vue').ComponentCustomProperties & {} & {
+                            $slots: Readonly<{
+                                default(): any;
+                                prepend(): any;
+                                append(): any;
+                                prefix(): any;
+                                suffix(): any;
+                                extra(): any;
+                            }> & {
+                                default(): any;
+                                prepend(): any;
+                                append(): any;
+                                prefix(): any;
+                                suffix(): any;
+                                extra(): any;
+                            };
+                        }) | null;
+                        uploadBtnRef: HTMLSpanElement;
+                        fileInputRef: HTMLInputElement;
+                    };
+                    $slots: Readonly<{
+                        [name: string]: import('vue').Slot<any> | undefined;
+                    }>;
+                    $root: import('vue').ComponentPublicInstance | null;
+                    $parent: import('vue').ComponentPublicInstance | null;
+                    $host: Element | null;
+                    $emit: (event: string, ...args: any[]) => void;
+                    $el: HTMLDivElement;
+                    $options: import('vue').ComponentOptionsBase<Readonly<import('../search/internal/SearchImageInput.vue').SearchImageInputPropsT> & Readonly<{
+                        [x: `on${Capitalize<any>}`]: ((...args: any) => any) | undefined;
+                    }>, {
+                        focus: () => void | undefined;
+                        blur: () => void | undefined;
+                        awaitUpload: () => Promise<void>;
+                        getUploadedUrl: () => string;
+                        getIsUploading: () => boolean;
+                        resetImage: () => void;
+                    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                        [x: string]: any;
+                    } & {
+                        [x: string]: any;
+                    }, string, {
+                        size: "small" | "medium" | "large";
+                        disabled: boolean;
+                        clearable: boolean;
+                        modelValue: string;
+                        preview: boolean;
+                        expanded: boolean;
+                        imageUrl: string;
+                        enableImageSearch: boolean;
+                        maxImageSize: number;
+                        showSuffix: boolean;
+                        inlineThumbnail: boolean;
+                        allowedImageTypes: string[];
+                    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                        beforeCreate?: (() => void) | (() => void)[];
+                        created?: (() => void) | (() => void)[];
+                        beforeMount?: (() => void) | (() => void)[];
+                        mounted?: (() => void) | (() => void)[];
+                        beforeUpdate?: (() => void) | (() => void)[];
+                        updated?: (() => void) | (() => void)[];
+                        activated?: (() => void) | (() => void)[];
+                        deactivated?: (() => void) | (() => void)[];
+                        beforeDestroy?: (() => void) | (() => void)[];
+                        beforeUnmount?: (() => void) | (() => void)[];
+                        destroyed?: (() => void) | (() => void)[];
+                        unmounted?: (() => void) | (() => void)[];
+                        renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                        renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                        errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+                    };
+                    $forceUpdate: () => void;
+                    $nextTick: typeof import('vue').nextTick;
+                    $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+                } & Readonly<{
+                    size: "small" | "medium" | "large";
+                    disabled: boolean;
+                    clearable: boolean;
+                    modelValue: string;
+                    preview: boolean;
+                    expanded: boolean;
+                    imageUrl: string;
+                    enableImageSearch: boolean;
+                    maxImageSize: number;
+                    showSuffix: boolean;
+                    inlineThumbnail: boolean;
+                    allowedImageTypes: string[];
+                }> & Omit<Readonly<import('../search/internal/SearchImageInput.vue').SearchImageInputPropsT> & Readonly<{
+                    [x: `on${Capitalize<any>}`]: ((...args: any) => any) | undefined;
+                }>, "blur" | "focus" | "awaitUpload" | "getUploadedUrl" | "getIsUploading" | "resetImage" | ("size" | "disabled" | "clearable" | "modelValue" | "preview" | "expanded" | "imageUrl" | "enableImageSearch" | "maxImageSize" | "showSuffix" | "inlineThumbnail" | "allowedImageTypes")> & {
+                    focus: () => void | undefined;
+                    blur: () => void | undefined;
+                    awaitUpload: () => Promise<void>;
+                    getUploadedUrl: () => string;
+                    getIsUploading: () => boolean;
+                    resetImage: () => void;
+                } & {} & import('vue').ComponentCustomProperties & {} & {
+                    $slots: {
+                        prefix?(_: {}): any;
+                        suffix?(_: {
+                            hasValue: boolean;
+                        }): any;
+                        preview?(_: {
+                            previewUrl: string;
+                            remove: () => void;
+                        }): any;
+                    };
+                }) | null;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any> | undefined;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: (event: string, ...args: any[]) => void;
+            $el: HTMLDivElement;
+            $options: import('vue').ComponentOptionsBase<Readonly<OSearchInputPropsT> & Readonly<{
+                [x: `on${Capitalize<any>}`]: ((...args: any) => any) | undefined;
+            }>, {
+                focus: () => void | undefined;
+                blur: () => void | undefined;
+                search: (overrideKeyword?: string) => Promise<void>;
+                saveHistory: (val?: string) => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                [x: string]: any;
+            } & {
+                [x: string]: any;
+            }, string, {
+                size: "small" | "medium" | "large";
+                clearable: boolean;
+                modelValue: string;
+                debounce: number;
+                imageUrl: string;
+                enableImageSearch: boolean;
+                maxImageSize: number;
+                onestepItems: import('../search').OSearchRecommendItem[];
+                suggestItems: import('../search').OSearchRecommendItem[];
+                historyItems: string[];
+                hotItems: string[];
+                highlightKeyword: boolean;
+                showSuggestEmpty: boolean;
+                storageKey: string;
+                storeHistory: boolean;
+                maxHistoryCount: number;
+                autoSaveHistory: boolean;
+                enableHistory: boolean;
+                suggestList: string[];
+                closeOnSearch: boolean;
+                closeOnClickOutside: boolean;
+                openOnFocus: boolean;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import('vue').nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+        } & Readonly<{
+            size: "small" | "medium" | "large";
+            clearable: boolean;
+            modelValue: string;
+            debounce: number;
+            imageUrl: string;
+            enableImageSearch: boolean;
+            maxImageSize: number;
+            onestepItems: import('../search').OSearchRecommendItem[];
+            suggestItems: import('../search').OSearchRecommendItem[];
+            historyItems: string[];
+            hotItems: string[];
+            highlightKeyword: boolean;
+            showSuggestEmpty: boolean;
+            storageKey: string;
+            storeHistory: boolean;
+            maxHistoryCount: number;
+            autoSaveHistory: boolean;
+            enableHistory: boolean;
+            suggestList: string[];
+            closeOnSearch: boolean;
+            closeOnClickOutside: boolean;
+            openOnFocus: boolean;
+        }> & Omit<Readonly<OSearchInputPropsT> & Readonly<{
+            [x: `on${Capitalize<any>}`]: ((...args: any) => any) | undefined;
+        }>, "search" | "blur" | "focus" | "saveHistory" | ("size" | "clearable" | "modelValue" | "debounce" | "imageUrl" | "enableImageSearch" | "maxImageSize" | "onestepItems" | "suggestItems" | "historyItems" | "hotItems" | "highlightKeyword" | "showSuggestEmpty" | "storageKey" | "storeHistory" | "maxHistoryCount" | "autoSaveHistory" | "enableHistory" | "suggestList" | "closeOnSearch" | "closeOnClickOutside" | "openOnFocus")> & {
+            focus: () => void | undefined;
+            blur: () => void | undefined;
+            search: (overrideKeyword?: string) => Promise<void>;
+            saveHistory: (val?: string) => void;
+        } & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: {
+                'input-prefix'?(_: {}): any;
+                'input-suffix'?(_: {
+                    hasValue: boolean;
+                }): any;
+                'image-preview'?(_: {
+                    previewUrl: string;
+                    remove: () => void;
+                }): any;
+                dropdown?(_: {
+                    keyword: string;
+                }): any;
+                'onestep-header'?(_: {
+                    items: import('../search').OSearchRecommendItem[];
+                }): any;
+                'onestep-content'?(_: {
+                    items: import('../search').OSearchRecommendItem[];
+                    keyword: string;
+                }): any;
+                'suggest-header'?(_: {
+                    items: import('../search').OSearchRecommendItem[];
+                }): any;
+                'suggest-content'?(_: {
+                    items: import('../search').OSearchRecommendItem[];
+                    keyword: string;
+                }): any;
+                'history-header'?(_: {
+                    items: string[];
+                }): any;
+                'history-content'?(_: {
+                    items: string[];
+                }): any;
+                'suggest-list'?(_: {
+                    items: string[];
+                }): any;
+            };
+        }) | null;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    search: (payload: OSearchPayload) => any;
+    back: () => any;
+    "update:searchInput": (value: string) => any;
+    "update:tab": (value: string | number) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onSearch?: ((payload: OSearchPayload) => any) | undefined;
+    onBack?: (() => any) | undefined;
+    "onUpdate:searchInput"?: ((value: string) => any) | undefined;
+    "onUpdate:tab"?: ((value: string | number) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    searchInputRef: ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly [x: `on${Capitalize<any>}`]: ((...args: any) => any) | undefined;
+            readonly modelValue?: string | undefined;
+            readonly imageUrl?: string | undefined;
+            readonly size?: "small" | "medium" | "large" | undefined;
+            readonly placeholder?: string | undefined;
+            readonly imagePlaceholder?: string | undefined;
+            readonly enableImageSearch?: boolean | undefined;
+            readonly uploadImage?: import('../search').OSearchUploadImageFn | undefined;
+            readonly maxImageSize?: number | undefined;
+            readonly imageUploadTooltip?: string | undefined;
+            readonly allowedImageTypes?: string[] | undefined;
+            readonly suggestItems?: import('../search').OSearchRecommendItem[] | undefined;
+            readonly onestepItems?: import('../search').OSearchRecommendItem[] | undefined;
+            readonly suggestTitle?: string | undefined;
+            readonly onestepTitle?: string | undefined;
+            readonly noDataText?: string | undefined;
+            readonly showSuggestEmpty?: boolean | undefined;
+            readonly highlightKeyword?: boolean | undefined;
+            readonly debounce?: number | undefined;
+            readonly enableHistory?: boolean | undefined;
+            readonly historyItems?: string[] | undefined;
+            readonly maxHistoryCount?: number | undefined;
+            readonly storeHistory?: boolean | undefined;
+            readonly storageKey?: string | undefined;
+            readonly historyTitle?: string | undefined;
+            readonly autoSaveHistory?: boolean | undefined;
+            readonly hotItems?: string[] | undefined;
+            readonly hotTitle?: string | undefined;
+            readonly suggestList?: string[] | undefined;
+            readonly suggestListLabel?: string | undefined;
+            readonly clearable?: boolean | undefined;
+            readonly closeOnSearch?: boolean | undefined;
+            readonly closeOnClickOutside?: boolean | undefined;
+            readonly openOnFocus?: boolean | undefined;
+            readonly alwaysInlineThumbnail?: boolean | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: import('vue').Attrs;
+        $refs: {
+            [x: string]: unknown;
+        } & {
+            wrapperRef: HTMLDivElement;
+            inputRef: ({
+                $: import('vue').ComponentInternalInstance;
+                $data: {};
+                $props: {
+                    readonly [x: `on${Capitalize<any>}`]: ((...args: any) => any) | undefined;
+                    readonly modelValue?: string | undefined;
+                    readonly imageUrl?: string | undefined;
+                    readonly placeholder?: string | undefined;
+                    readonly imagePlaceholder?: string | undefined;
+                    readonly size?: "small" | "medium" | "large" | undefined;
+                    readonly enableImageSearch?: boolean | undefined;
+                    readonly uploadImage?: import('../search').OSearchUploadImageFn | undefined;
+                    readonly maxImageSize?: number | undefined;
+                    readonly imageUploadTooltip?: string | undefined;
+                    readonly expanded?: boolean | undefined;
+                    readonly clearable?: boolean | undefined;
+                    readonly showSuffix?: boolean | undefined;
+                    readonly inlineThumbnail?: boolean | undefined;
+                    readonly preview?: boolean | undefined;
+                    readonly disabled?: boolean | undefined;
+                    readonly allowedImageTypes?: string[] | undefined;
+                } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+                $attrs: import('vue').Attrs;
+                $refs: {
+                    [x: string]: unknown;
+                } & {
+                    inputRef: ({
+                        $: import('vue').ComponentInternalInstance;
+                        $data: {};
+                        $props: Partial<{
+                            color: "normal" | "primary" | "success" | "warning" | "danger";
+                            type: "text" | "password";
+                            disabled: boolean | undefined;
+                            variant: "solid" | "outline" | "text";
+                            clearable: boolean | undefined;
+                            readonly: boolean;
+                            noKeyboard: boolean;
+                            showLength: "auto" | "always" | "never";
+                            inputOnOutlimit: boolean;
+                            showPasswordEvent: "click" | "pointerdown";
+                            autoWidth: boolean;
+                            passwordPlaceholder: string;
+                            onlyNumericInput: boolean;
+                        }> & Omit<{
+                            readonly type: "text" | "password";
+                            readonly color: "danger" | "warning" | "success" | "primary" | "normal";
+                            readonly variant: "solid" | "outline" | "text";
+                            readonly readonly: boolean;
+                            readonly noKeyboard: boolean;
+                            readonly showLength: "auto" | "always" | "never";
+                            readonly inputOnOutlimit: boolean;
+                            readonly showPasswordEvent: "click" | "pointerdown";
+                            readonly autoWidth: boolean;
+                            readonly passwordPlaceholder: string;
+                            readonly onlyNumericInput: boolean;
+                            readonly size?: "small" | "large" | "medium" | undefined;
+                            readonly round?: import('@opensig/opendesign').RoundT | undefined;
+                            readonly disabled?: boolean | undefined;
+                            readonly clearable?: boolean | undefined;
+                            readonly modelValue?: string | number | undefined;
+                            readonly defaultValue?: string | number | undefined;
+                            readonly placeholder?: string | undefined;
+                            readonly inputId?: string | undefined;
+                            readonly minLength?: number | undefined;
+                            readonly maxLength?: number | undefined;
+                            readonly getLength?: ((val: string) => number) | undefined;
+                            readonly format?: ((value: string) => string) | undefined;
+                            readonly validate?: ((value: string) => boolean) | undefined;
+                            readonly valueOnInvalidChange?: boolean | ((inputValue: string, lastValidInputValue: string) => string) | undefined;
+                            readonly onInput?: ((evt: Event, value: string) => any) | undefined | undefined;
+                            readonly onClear?: ((evt?: Event | undefined) => any) | undefined | undefined;
+                            readonly onBlur?: ((evt: FocusEvent) => any) | undefined | undefined;
+                            readonly onChange?: ((value: string) => any) | undefined | undefined;
+                            readonly onFocus?: ((evt: FocusEvent) => any) | undefined | undefined;
+                            readonly "onUpdate:modelValue"?: ((value: string) => any) | undefined | undefined;
+                            readonly onPressEnter?: ((evt: KeyboardEvent) => any) | undefined | undefined;
+                        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "type" | "color" | "variant" | "disabled" | "clearable" | "readonly" | "noKeyboard" | "showLength" | "inputOnOutlimit" | "showPasswordEvent" | "autoWidth" | "passwordPlaceholder" | "onlyNumericInput">;
+                        $attrs: import('vue').Attrs;
+                        $refs: {
+                            [x: string]: unknown;
+                        };
+                        $slots: Readonly<{
+                            [name: string]: import('vue').Slot<any> | undefined;
+                        }>;
+                        $root: import('vue').ComponentPublicInstance | null;
+                        $parent: import('vue').ComponentPublicInstance | null;
+                        $host: Element | null;
+                        $emit: ((event: "change", value: string) => void) & ((event: "input", evt: Event, value: string) => void) & ((event: "blur", evt: FocusEvent) => void) & ((event: "focus", evt: FocusEvent) => void) & ((event: "clear", evt?: Event | undefined) => void) & ((event: "update:modelValue", value: string) => void) & ((event: "pressEnter", evt: KeyboardEvent) => void);
+                        $el: any;
+                        $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+                            size: {
+                                type: import('vue').PropType<import('@opensig/opendesign').SizeT>;
+                            };
+                            round: {
+                                type: import('vue').PropType<import('@opensig/opendesign').RoundT>;
+                            };
+                            color: {
+                                type: import('vue').PropType<import('@opensig/opendesign').Color2T>;
+                                default: string;
+                            };
+                            variant: {
+                                type: import('vue').PropType<import('@opensig/opendesign').VariantT>;
+                                default: string;
+                            };
+                            modelValue: {
+                                type: (NumberConstructor | StringConstructor)[];
+                            };
+                            defaultValue: {
+                                type: (NumberConstructor | StringConstructor)[];
+                            };
+                            type: {
+                                type: import('vue').PropType<"text" | "password">;
+                                default: string;
+                            };
+                            placeholder: {
+                                type: StringConstructor;
+                            };
+                            inputId: {
+                                type: StringConstructor;
+                            };
+                            disabled: {
+                                type: import('vue').PropType<boolean | undefined>;
+                                default: undefined;
+                            };
+                            readonly: {
+                                type: BooleanConstructor;
+                            };
+                            noKeyboard: {
+                                type: BooleanConstructor;
+                            };
+                            clearable: {
+                                type: import('vue').PropType<boolean | undefined>;
+                                default: undefined;
+                            };
+                            minLength: {
+                                type: NumberConstructor;
+                            };
+                            maxLength: {
+                                type: NumberConstructor;
+                            };
+                            showLength: {
+                                type: import('vue').PropType<"always" | "auto" | "never">;
+                                default: string;
+                            };
+                            getLength: {
+                                type: import('vue').PropType<(val: string) => number>;
+                            };
+                            inputOnOutlimit: {
+                                type: BooleanConstructor;
+                                default: boolean;
+                            };
+                            format: {
+                                type: import('vue').PropType<(value: string) => string>;
+                            };
+                            validate: {
+                                type: import('vue').PropType<(value: string) => boolean>;
+                            };
+                            valueOnInvalidChange: {
+                                type: import('vue').PropType<boolean | ((inputValue: string, lastValidInputValue: string) => string)>;
+                            };
+                            showPasswordEvent: {
+                                type: import('vue').PropType<"click" | "pointerdown">;
+                                default: string;
+                            };
+                            autoWidth: {
+                                type: BooleanConstructor;
+                            };
+                            passwordPlaceholder: {
+                                type: StringConstructor;
+                                default: string;
+                            };
+                            onlyNumericInput: {
+                                type: BooleanConstructor;
+                            };
+                        }>> & Readonly<{
+                            onInput?: ((evt: Event, value: string) => any) | undefined;
+                            onClear?: ((evt?: Event | undefined) => any) | undefined;
+                            onBlur?: ((evt: FocusEvent) => any) | undefined;
+                            onChange?: ((value: string) => any) | undefined;
+                            onFocus?: ((evt: FocusEvent) => any) | undefined;
+                            "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+                            onPressEnter?: ((evt: KeyboardEvent) => any) | undefined;
+                        }>, {
+                            focus: () => void | undefined;
+                            blur: () => void | undefined;
+                            clear: () => void | undefined;
+                            inputEl: () => HTMLInputElement | HTMLTextAreaElement | undefined;
+                            togglePassword: () => void | undefined;
+                        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                            input: (evt: Event, value: string) => any;
+                            clear: (evt?: Event | undefined) => any;
+                            blur: (evt: FocusEvent) => any;
+                            change: (value: string) => any;
+                            focus: (evt: FocusEvent) => any;
+                            "update:modelValue": (value: string) => any;
+                            pressEnter: (evt: KeyboardEvent) => any;
+                        }, string, {
+                            color: "normal" | "primary" | "success" | "warning" | "danger";
+                            type: "text" | "password";
+                            disabled: boolean | undefined;
+                            variant: "solid" | "outline" | "text";
+                            clearable: boolean | undefined;
+                            readonly: boolean;
+                            noKeyboard: boolean;
+                            showLength: "auto" | "always" | "never";
+                            inputOnOutlimit: boolean;
+                            showPasswordEvent: "click" | "pointerdown";
+                            autoWidth: boolean;
+                            passwordPlaceholder: string;
+                            onlyNumericInput: boolean;
+                        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                            beforeCreate?: (() => void) | (() => void)[];
+                            created?: (() => void) | (() => void)[];
+                            beforeMount?: (() => void) | (() => void)[];
+                            mounted?: (() => void) | (() => void)[];
+                            beforeUpdate?: (() => void) | (() => void)[];
+                            updated?: (() => void) | (() => void)[];
+                            activated?: (() => void) | (() => void)[];
+                            deactivated?: (() => void) | (() => void)[];
+                            beforeDestroy?: (() => void) | (() => void)[];
+                            beforeUnmount?: (() => void) | (() => void)[];
+                            destroyed?: (() => void) | (() => void)[];
+                            unmounted?: (() => void) | (() => void)[];
+                            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+                        };
+                        $forceUpdate: () => void;
+                        $nextTick: typeof import('vue').nextTick;
+                        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+                    } & Readonly<{
+                        color: "normal" | "primary" | "success" | "warning" | "danger";
+                        type: "text" | "password";
+                        disabled: boolean | undefined;
+                        variant: "solid" | "outline" | "text";
+                        clearable: boolean | undefined;
+                        readonly: boolean;
+                        noKeyboard: boolean;
+                        showLength: "auto" | "always" | "never";
+                        inputOnOutlimit: boolean;
+                        showPasswordEvent: "click" | "pointerdown";
+                        autoWidth: boolean;
+                        passwordPlaceholder: string;
+                        onlyNumericInput: boolean;
+                    }> & Omit<Readonly<import('vue').ExtractPropTypes<{
+                        size: {
+                            type: import('vue').PropType<import('@opensig/opendesign').SizeT>;
+                        };
+                        round: {
+                            type: import('vue').PropType<import('@opensig/opendesign').RoundT>;
+                        };
+                        color: {
+                            type: import('vue').PropType<import('@opensig/opendesign').Color2T>;
+                            default: string;
+                        };
+                        variant: {
+                            type: import('vue').PropType<import('@opensig/opendesign').VariantT>;
+                            default: string;
+                        };
+                        modelValue: {
+                            type: (NumberConstructor | StringConstructor)[];
+                        };
+                        defaultValue: {
+                            type: (NumberConstructor | StringConstructor)[];
+                        };
+                        type: {
+                            type: import('vue').PropType<"text" | "password">;
+                            default: string;
+                        };
+                        placeholder: {
+                            type: StringConstructor;
+                        };
+                        inputId: {
+                            type: StringConstructor;
+                        };
+                        disabled: {
+                            type: import('vue').PropType<boolean | undefined>;
+                            default: undefined;
+                        };
+                        readonly: {
+                            type: BooleanConstructor;
+                        };
+                        noKeyboard: {
+                            type: BooleanConstructor;
+                        };
+                        clearable: {
+                            type: import('vue').PropType<boolean | undefined>;
+                            default: undefined;
+                        };
+                        minLength: {
+                            type: NumberConstructor;
+                        };
+                        maxLength: {
+                            type: NumberConstructor;
+                        };
+                        showLength: {
+                            type: import('vue').PropType<"always" | "auto" | "never">;
+                            default: string;
+                        };
+                        getLength: {
+                            type: import('vue').PropType<(val: string) => number>;
+                        };
+                        inputOnOutlimit: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        format: {
+                            type: import('vue').PropType<(value: string) => string>;
+                        };
+                        validate: {
+                            type: import('vue').PropType<(value: string) => boolean>;
+                        };
+                        valueOnInvalidChange: {
+                            type: import('vue').PropType<boolean | ((inputValue: string, lastValidInputValue: string) => string)>;
+                        };
+                        showPasswordEvent: {
+                            type: import('vue').PropType<"click" | "pointerdown">;
+                            default: string;
+                        };
+                        autoWidth: {
+                            type: BooleanConstructor;
+                        };
+                        passwordPlaceholder: {
+                            type: StringConstructor;
+                            default: string;
+                        };
+                        onlyNumericInput: {
+                            type: BooleanConstructor;
+                        };
+                    }>> & Readonly<{
+                        onInput?: ((evt: Event, value: string) => any) | undefined;
+                        onClear?: ((evt?: Event | undefined) => any) | undefined;
+                        onBlur?: ((evt: FocusEvent) => any) | undefined;
+                        onChange?: ((value: string) => any) | undefined;
+                        onFocus?: ((evt: FocusEvent) => any) | undefined;
+                        "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+                        onPressEnter?: ((evt: KeyboardEvent) => any) | undefined;
+                    }>, "blur" | "focus" | "type" | "color" | "variant" | "disabled" | "clear" | "clearable" | "readonly" | "noKeyboard" | "showLength" | "inputOnOutlimit" | "showPasswordEvent" | "autoWidth" | "passwordPlaceholder" | "onlyNumericInput" | "inputEl" | "togglePassword"> & {
+                        focus: () => void | undefined;
+                        blur: () => void | undefined;
+                        clear: () => void | undefined;
+                        inputEl: () => HTMLInputElement | HTMLTextAreaElement | undefined;
+                        togglePassword: () => void | undefined;
+                    } & {} & import('vue').ComponentCustomProperties & {} & {
+                        $slots: Readonly<{
+                            default(): any;
+                            prepend(): any;
+                            append(): any;
+                            prefix(): any;
+                            suffix(): any;
+                            extra(): any;
+                        }> & {
+                            default(): any;
+                            prepend(): any;
+                            append(): any;
+                            prefix(): any;
+                            suffix(): any;
+                            extra(): any;
+                        };
+                    }) | null;
+                    uploadBtnRef: HTMLSpanElement;
+                    fileInputRef: HTMLInputElement;
+                };
+                $slots: Readonly<{
+                    [name: string]: import('vue').Slot<any> | undefined;
+                }>;
+                $root: import('vue').ComponentPublicInstance | null;
+                $parent: import('vue').ComponentPublicInstance | null;
+                $host: Element | null;
+                $emit: (event: string, ...args: any[]) => void;
+                $el: HTMLDivElement;
+                $options: import('vue').ComponentOptionsBase<Readonly<import('../search/internal/SearchImageInput.vue').SearchImageInputPropsT> & Readonly<{
+                    [x: `on${Capitalize<any>}`]: ((...args: any) => any) | undefined;
+                }>, {
+                    focus: () => void | undefined;
+                    blur: () => void | undefined;
+                    awaitUpload: () => Promise<void>;
+                    getUploadedUrl: () => string;
+                    getIsUploading: () => boolean;
+                    resetImage: () => void;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                    [x: string]: any;
+                } & {
+                    [x: string]: any;
+                }, string, {
+                    size: "small" | "medium" | "large";
+                    disabled: boolean;
+                    clearable: boolean;
+                    modelValue: string;
+                    preview: boolean;
+                    expanded: boolean;
+                    imageUrl: string;
+                    enableImageSearch: boolean;
+                    maxImageSize: number;
+                    showSuffix: boolean;
+                    inlineThumbnail: boolean;
+                    allowedImageTypes: string[];
+                }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                    beforeCreate?: (() => void) | (() => void)[];
+                    created?: (() => void) | (() => void)[];
+                    beforeMount?: (() => void) | (() => void)[];
+                    mounted?: (() => void) | (() => void)[];
+                    beforeUpdate?: (() => void) | (() => void)[];
+                    updated?: (() => void) | (() => void)[];
+                    activated?: (() => void) | (() => void)[];
+                    deactivated?: (() => void) | (() => void)[];
+                    beforeDestroy?: (() => void) | (() => void)[];
+                    beforeUnmount?: (() => void) | (() => void)[];
+                    destroyed?: (() => void) | (() => void)[];
+                    unmounted?: (() => void) | (() => void)[];
+                    renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                    renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                    errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+                };
+                $forceUpdate: () => void;
+                $nextTick: typeof import('vue').nextTick;
+                $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+            } & Readonly<{
+                size: "small" | "medium" | "large";
+                disabled: boolean;
+                clearable: boolean;
+                modelValue: string;
+                preview: boolean;
+                expanded: boolean;
+                imageUrl: string;
+                enableImageSearch: boolean;
+                maxImageSize: number;
+                showSuffix: boolean;
+                inlineThumbnail: boolean;
+                allowedImageTypes: string[];
+            }> & Omit<Readonly<import('../search/internal/SearchImageInput.vue').SearchImageInputPropsT> & Readonly<{
+                [x: `on${Capitalize<any>}`]: ((...args: any) => any) | undefined;
+            }>, "blur" | "focus" | "awaitUpload" | "getUploadedUrl" | "getIsUploading" | "resetImage" | ("size" | "disabled" | "clearable" | "modelValue" | "preview" | "expanded" | "imageUrl" | "enableImageSearch" | "maxImageSize" | "showSuffix" | "inlineThumbnail" | "allowedImageTypes")> & {
+                focus: () => void | undefined;
+                blur: () => void | undefined;
+                awaitUpload: () => Promise<void>;
+                getUploadedUrl: () => string;
+                getIsUploading: () => boolean;
+                resetImage: () => void;
+            } & {} & import('vue').ComponentCustomProperties & {} & {
+                $slots: {
+                    prefix?(_: {}): any;
+                    suffix?(_: {
+                        hasValue: boolean;
+                    }): any;
+                    preview?(_: {
+                        previewUrl: string;
+                        remove: () => void;
+                    }): any;
+                };
+            }) | null;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any> | undefined;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: HTMLDivElement;
+        $options: import('vue').ComponentOptionsBase<Readonly<OSearchInputPropsT> & Readonly<{
+            [x: `on${Capitalize<any>}`]: ((...args: any) => any) | undefined;
+        }>, {
+            focus: () => void | undefined;
+            blur: () => void | undefined;
+            search: (overrideKeyword?: string) => Promise<void>;
+            saveHistory: (val?: string) => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            [x: string]: any;
+        } & {
+            [x: string]: any;
+        }, string, {
+            size: "small" | "medium" | "large";
+            clearable: boolean;
+            modelValue: string;
+            debounce: number;
+            imageUrl: string;
+            enableImageSearch: boolean;
+            maxImageSize: number;
+            onestepItems: import('../search').OSearchRecommendItem[];
+            suggestItems: import('../search').OSearchRecommendItem[];
+            historyItems: string[];
+            hotItems: string[];
+            highlightKeyword: boolean;
+            showSuggestEmpty: boolean;
+            storageKey: string;
+            storeHistory: boolean;
+            maxHistoryCount: number;
+            autoSaveHistory: boolean;
+            enableHistory: boolean;
+            suggestList: string[];
+            closeOnSearch: boolean;
+            closeOnClickOutside: boolean;
+            openOnFocus: boolean;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import('vue').nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+    } & Readonly<{
+        size: "small" | "medium" | "large";
+        clearable: boolean;
+        modelValue: string;
+        debounce: number;
+        imageUrl: string;
+        enableImageSearch: boolean;
+        maxImageSize: number;
+        onestepItems: import('../search').OSearchRecommendItem[];
+        suggestItems: import('../search').OSearchRecommendItem[];
+        historyItems: string[];
+        hotItems: string[];
+        highlightKeyword: boolean;
+        showSuggestEmpty: boolean;
+        storageKey: string;
+        storeHistory: boolean;
+        maxHistoryCount: number;
+        autoSaveHistory: boolean;
+        enableHistory: boolean;
+        suggestList: string[];
+        closeOnSearch: boolean;
+        closeOnClickOutside: boolean;
+        openOnFocus: boolean;
+    }> & Omit<Readonly<OSearchInputPropsT> & Readonly<{
+        [x: `on${Capitalize<any>}`]: ((...args: any) => any) | undefined;
+    }>, "search" | "blur" | "focus" | "saveHistory" | ("size" | "clearable" | "modelValue" | "debounce" | "imageUrl" | "enableImageSearch" | "maxImageSize" | "onestepItems" | "suggestItems" | "historyItems" | "hotItems" | "highlightKeyword" | "showSuggestEmpty" | "storageKey" | "storeHistory" | "maxHistoryCount" | "autoSaveHistory" | "enableHistory" | "suggestList" | "closeOnSearch" | "closeOnClickOutside" | "openOnFocus")> & {
+        focus: () => void | undefined;
+        blur: () => void | undefined;
+        search: (overrideKeyword?: string) => Promise<void>;
+        saveHistory: (val?: string) => void;
+    } & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            'input-prefix'?(_: {}): any;
+            'input-suffix'?(_: {
+                hasValue: boolean;
+            }): any;
+            'image-preview'?(_: {
+                previewUrl: string;
+                remove: () => void;
+            }): any;
+            dropdown?(_: {
+                keyword: string;
+            }): any;
+            'onestep-header'?(_: {
+                items: import('../search').OSearchRecommendItem[];
+            }): any;
+            'onestep-content'?(_: {
+                items: import('../search').OSearchRecommendItem[];
+                keyword: string;
+            }): any;
+            'suggest-header'?(_: {
+                items: import('../search').OSearchRecommendItem[];
+            }): any;
+            'suggest-content'?(_: {
+                items: import('../search').OSearchRecommendItem[];
+                keyword: string;
+            }): any;
+            'history-header'?(_: {
+                items: string[];
+            }): any;
+            'history-content'?(_: {
+                items: string[];
+            }): any;
+            'suggest-list'?(_: {
+                items: string[];
+            }): any;
+        };
+    }) | null;
+}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};