@opendesign-plus-test/components 0.0.1-rc.42 → 0.0.1-rc.45

package/dist/components/search/composables/useImageSearch.d.ts

@@ -0,0 +1,48 @@
+import { Ref } from '../../../../vue/dist/vue.esm-bundler.js';
+import { OSearchUploadImageFn } from '../types';
+export interface UseImageSearchOptions {
+    uploadImage?: Ref<OSearchUploadImageFn | undefined>;
+    maxImageSize: Ref<number>;
+    allowedImageTypes?: Ref<string[]>;
+    onUploadStart?: (file: File) => void;
+    onUploadSuccess?: (url: string, file: File) => void;
+    onUploadError?: (error: unknown, file: File) => void;
+    onValidationError?: (reason: 'size' | 'type', file: File) => void;
+}
+export declare function useImageSearch(options: UseImageSearchOptions): {
+    previewUrl: Ref<string, string>;
+    file: Ref<{
+        readonly lastModified: number;
+        readonly name: string;
+        readonly webkitRelativePath: string;
+        readonly size: number;
+        readonly type: string;
+        arrayBuffer: () => Promise<ArrayBuffer>;
+        bytes: () => Promise<Uint8Array>;
+        slice: (start?: number, end?: number, contentType?: string) => Blob;
+        stream: () => ReadableStream<Uint8Array>;
+        text: () => Promise<string>;
+    } | null, File | {
+        readonly lastModified: number;
+        readonly name: string;
+        readonly webkitRelativePath: string;
+        readonly size: number;
+        readonly type: string;
+        arrayBuffer: () => Promise<ArrayBuffer>;
+        bytes: () => Promise<Uint8Array>;
+        slice: (start?: number, end?: number, contentType?: string) => Blob;
+        stream: () => ReadableStream<Uint8Array>;
+        text: () => Promise<string>;
+    } | null>;
+    uploadedUrl: Ref<string, string>;
+    isUploading: Ref<boolean, boolean>;
+    onPaste: (event: ClipboardEvent) => void;
+    onDrop: (event: DragEvent) => void;
+    onDragOver: (event: DragEvent) => void;
+    onFileChange: (event: Event) => void;
+    pickFile: (input: HTMLInputElement | undefined) => void;
+    handleImageFile: (f: File) => void;
+    reset: () => void;
+    setExternalUrl: (url: string) => void;
+    awaitUpload: () => Promise<void>;
+};

package/dist/components/search/composables/useKeywordHighlight.d.ts

@@ -0,0 +1,2 @@
+import { OSearchHighlightPart } from '../types';
+export declare function highlightKeywordParts(text: string, keyword: string): OSearchHighlightPart[];

package/dist/components/search/composables/useSearchHistory.d.ts

@@ -0,0 +1,14 @@
+import { Ref } from '../../../../vue/dist/vue.esm-bundler.js';
+export interface UseSearchHistoryOptions {
+    initial: Ref<string[]>;
+    storageKey: Ref<string>;
+    storeHistory: Ref<boolean>;
+    maxHistoryCount: Ref<number>;
+    onChange?: (items: string[]) => void;
+}
+export declare function useSearchHistory(options: UseSearchHistoryOptions): {
+    items: Ref<string[], string[]>;
+    push: (val: string) => void;
+    remove: (val: string) => void;
+    clearAll: () => void;
+};

package/dist/components/search/index.d.ts

@@ -0,0 +1,590 @@
+import { App } from '../../../vue/dist/vue.esm-bundler.js';
+declare const OSearchInput: {
+    new (...args: any[]): import('../../../vue/dist/vue.esm-bundler.js').CreateComponentPublicInstanceWithMixins<Readonly<import('./OSearchInput.vue').OSearchInputPropsT> & Readonly<{
+        [x: `on${Capitalize<any>}`]: ((...args: any) => any) | undefined;
+    }>, {
+        focus: () => void | undefined;
+        blur: () => void | undefined;
+        search: () => Promise<void>;
+        saveHistory: (val?: string) => void;
+    }, {}, {}, {}, import('../../../vue/dist/vue.esm-bundler.js').ComponentOptionsMixin, import('../../../vue/dist/vue.esm-bundler.js').ComponentOptionsMixin, {
+        [x: string]: any;
+    } & {
+        [x: string]: any;
+    }, import('../../../vue/dist/vue.esm-bundler.js').PublicProps, {
+        size: "small" | "medium" | "large";
+        modelValue: string;
+        imageUrl: string;
+        enableImageSearch: boolean;
+        maxImageSize: number;
+        clearable: boolean;
+        onestepItems: import('./types').OSearchRecommendItem[];
+        suggestItems: import('./types').OSearchRecommendItem[];
+        historyItems: string[];
+        highlightKeyword: boolean;
+        showSuggestEmpty: boolean;
+        storageKey: string;
+        storeHistory: boolean;
+        maxHistoryCount: number;
+        debounce: number;
+        autoSaveHistory: boolean;
+        enableHistory: boolean;
+        suggestList: string[];
+        allowHtmlInSuggest: boolean;
+        closeOnSearch: boolean;
+        closeOnClickOutside: boolean;
+        openOnFocus: boolean;
+    }, false, {}, {}, import('../../../vue/dist/vue.esm-bundler.js').GlobalComponents, import('../../../vue/dist/vue.esm-bundler.js').GlobalDirectives, string, {
+        wrapperRef: HTMLDivElement;
+        inputRef: ({
+            $: import('../../../vue/dist/vue.esm-bundler.js').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('./types').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/dist/vue.esm-bundler.js').VNodeProps & import('../../../vue/dist/vue.esm-bundler.js').AllowedComponentProps & import('../../../vue/dist/vue.esm-bundler.js').ComponentCustomProps;
+            $attrs: import('../../../vue/dist/vue.esm-bundler.js').Attrs;
+            $refs: {
+                [x: string]: unknown;
+            } & {
+                inputRef: ({
+                    $: import('../../../vue/dist/vue.esm-bundler.js').ComponentInternalInstance;
+                    $data: {};
+                    $props: Partial<{
+                        color: "normal" | "primary" | "success" | "warning" | "danger";
+                        type: "text" | "password";
+                        disabled: boolean;
+                        variant: "solid" | "outline" | "text";
+                        clearable: boolean;
+                        readonly: boolean;
+                        showLength: "auto" | "always" | "never";
+                        inputOnOutlimit: boolean;
+                        showPasswordEvent: "click" | "pointerdown";
+                        autoWidth: boolean;
+                        passwordPlaceholder: string;
+                        onlyNumericInput: boolean;
+                    }> & Omit<{
+                        readonly type: "text" | "password";
+                        readonly color: "primary" | "normal" | "success" | "warning" | "danger";
+                        readonly variant: "text" | "solid" | "outline";
+                        readonly disabled: boolean;
+                        readonly clearable: boolean;
+                        readonly readonly: boolean;
+                        readonly showLength: "never" | "always" | "auto";
+                        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 placeholder?: string | undefined;
+                        readonly defaultValue?: string | number | undefined;
+                        readonly modelValue?: string | number | 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/dist/vue.esm-bundler.js').VNodeProps & import('../../../vue/dist/vue.esm-bundler.js').AllowedComponentProps & import('../../../vue/dist/vue.esm-bundler.js').ComponentCustomProps, "type" | "color" | "variant" | "disabled" | "clearable" | "readonly" | "showLength" | "inputOnOutlimit" | "showPasswordEvent" | "autoWidth" | "passwordPlaceholder" | "onlyNumericInput">;
+                    $attrs: import('../../../vue/dist/vue.esm-bundler.js').Attrs;
+                    $refs: {
+                        [x: string]: unknown;
+                    };
+                    $slots: Readonly<{
+                        [name: string]: import('../../../vue/dist/vue.esm-bundler.js').Slot<any> | undefined;
+                    }>;
+                    $root: import('../../../vue/dist/vue.esm-bundler.js').ComponentPublicInstance | null;
+                    $parent: import('../../../vue/dist/vue.esm-bundler.js').ComponentPublicInstance | null;
+                    $host: Element | null;
+                    $emit: ((event: "input", evt: Event, value: string) => void) & ((event: "clear", evt?: Event | undefined) => void) & ((event: "change", value: string) => void) & ((event: "blur", evt: FocusEvent) => void) & ((event: "focus", evt: FocusEvent) => void) & ((event: "update:modelValue", value: string) => void) & ((event: "pressEnter", evt: KeyboardEvent) => void);
+                    $el: any;
+                    $options: import('../../../vue/dist/vue.esm-bundler.js').ComponentOptionsBase<Readonly<import('../../../vue/dist/vue.esm-bundler.js').ExtractPropTypes<{
+                        size: {
+                            type: import('../../../vue/dist/vue.esm-bundler.js').PropType<import('@opensig/opendesign').SizeT>;
+                        };
+                        round: {
+                            type: import('../../../vue/dist/vue.esm-bundler.js').PropType<import('@opensig/opendesign').RoundT>;
+                        };
+                        color: {
+                            type: import('../../../vue/dist/vue.esm-bundler.js').PropType<import('@opensig/opendesign').Color2T>;
+                            default: string;
+                        };
+                        variant: {
+                            type: import('../../../vue/dist/vue.esm-bundler.js').PropType<import('@opensig/opendesign').VariantT>;
+                            default: string;
+                        };
+                        modelValue: {
+                            type: (NumberConstructor | StringConstructor)[];
+                        };
+                        defaultValue: {
+                            type: (NumberConstructor | StringConstructor)[];
+                        };
+                        type: {
+                            type: import('../../../vue/dist/vue.esm-bundler.js').PropType<"text" | "password">;
+                            default: string;
+                        };
+                        placeholder: {
+                            type: StringConstructor;
+                        };
+                        inputId: {
+                            type: StringConstructor;
+                        };
+                        disabled: {
+                            type: BooleanConstructor;
+                        };
+                        readonly: {
+                            type: BooleanConstructor;
+                        };
+                        clearable: {
+                            type: BooleanConstructor;
+                        };
+                        minLength: {
+                            type: NumberConstructor;
+                        };
+                        maxLength: {
+                            type: NumberConstructor;
+                        };
+                        showLength: {
+                            type: import('../../../vue/dist/vue.esm-bundler.js').PropType<"always" | "auto" | "never">;
+                            default: string;
+                        };
+                        getLength: {
+                            type: import('../../../vue/dist/vue.esm-bundler.js').PropType<(val: string) => number>;
+                        };
+                        inputOnOutlimit: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        format: {
+                            type: import('../../../vue/dist/vue.esm-bundler.js').PropType<(value: string) => string>;
+                        };
+                        validate: {
+                            type: import('../../../vue/dist/vue.esm-bundler.js').PropType<(value: string) => boolean>;
+                        };
+                        valueOnInvalidChange: {
+                            type: import('../../../vue/dist/vue.esm-bundler.js').PropType<boolean | ((inputValue: string, lastValidInputValue: string) => string)>;
+                        };
+                        showPasswordEvent: {
+                            type: import('../../../vue/dist/vue.esm-bundler.js').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/dist/vue.esm-bundler.js').ComponentOptionsMixin, import('../../../vue/dist/vue.esm-bundler.js').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;
+                        variant: "solid" | "outline" | "text";
+                        clearable: boolean;
+                        readonly: boolean;
+                        showLength: "auto" | "always" | "never";
+                        inputOnOutlimit: boolean;
+                        showPasswordEvent: "click" | "pointerdown";
+                        autoWidth: boolean;
+                        passwordPlaceholder: string;
+                        onlyNumericInput: boolean;
+                    }, {}, string, {}, import('../../../vue/dist/vue.esm-bundler.js').GlobalComponents, import('../../../vue/dist/vue.esm-bundler.js').GlobalDirectives, string, import('../../../vue/dist/vue.esm-bundler.js').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/dist/vue.esm-bundler.js').DebuggerEvent) => void) | ((e: import('../../../vue/dist/vue.esm-bundler.js').DebuggerEvent) => void)[];
+                        renderTriggered?: ((e: import('../../../vue/dist/vue.esm-bundler.js').DebuggerEvent) => void) | ((e: import('../../../vue/dist/vue.esm-bundler.js').DebuggerEvent) => void)[];
+                        errorCaptured?: ((err: unknown, instance: import('../../../vue/dist/vue.esm-bundler.js').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('../../../vue/dist/vue.esm-bundler.js').ComponentPublicInstance | null, info: string) => boolean | void)[];
+                    };
+                    $forceUpdate: () => void;
+                    $nextTick: typeof import('../../../vue/dist/vue.esm-bundler.js').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/dist/vue.esm-bundler.js').WatchOptions): import('../../../vue/dist/vue.esm-bundler.js').WatchStopHandle;
+                } & Readonly<{
+                    color: "normal" | "primary" | "success" | "warning" | "danger";
+                    type: "text" | "password";
+                    disabled: boolean;
+                    variant: "solid" | "outline" | "text";
+                    clearable: boolean;
+                    readonly: boolean;
+                    showLength: "auto" | "always" | "never";
+                    inputOnOutlimit: boolean;
+                    showPasswordEvent: "click" | "pointerdown";
+                    autoWidth: boolean;
+                    passwordPlaceholder: string;
+                    onlyNumericInput: boolean;
+                }> & Omit<Readonly<import('../../../vue/dist/vue.esm-bundler.js').ExtractPropTypes<{
+                    size: {
+                        type: import('../../../vue/dist/vue.esm-bundler.js').PropType<import('@opensig/opendesign').SizeT>;
+                    };
+                    round: {
+                        type: import('../../../vue/dist/vue.esm-bundler.js').PropType<import('@opensig/opendesign').RoundT>;
+                    };
+                    color: {
+                        type: import('../../../vue/dist/vue.esm-bundler.js').PropType<import('@opensig/opendesign').Color2T>;
+                        default: string;
+                    };
+                    variant: {
+                        type: import('../../../vue/dist/vue.esm-bundler.js').PropType<import('@opensig/opendesign').VariantT>;
+                        default: string;
+                    };
+                    modelValue: {
+                        type: (NumberConstructor | StringConstructor)[];
+                    };
+                    defaultValue: {
+                        type: (NumberConstructor | StringConstructor)[];
+                    };
+                    type: {
+                        type: import('../../../vue/dist/vue.esm-bundler.js').PropType<"text" | "password">;
+                        default: string;
+                    };
+                    placeholder: {
+                        type: StringConstructor;
+                    };
+                    inputId: {
+                        type: StringConstructor;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                    };
+                    readonly: {
+                        type: BooleanConstructor;
+                    };
+                    clearable: {
+                        type: BooleanConstructor;
+                    };
+                    minLength: {
+                        type: NumberConstructor;
+                    };
+                    maxLength: {
+                        type: NumberConstructor;
+                    };
+                    showLength: {
+                        type: import('../../../vue/dist/vue.esm-bundler.js').PropType<"always" | "auto" | "never">;
+                        default: string;
+                    };
+                    getLength: {
+                        type: import('../../../vue/dist/vue.esm-bundler.js').PropType<(val: string) => number>;
+                    };
+                    inputOnOutlimit: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    format: {
+                        type: import('../../../vue/dist/vue.esm-bundler.js').PropType<(value: string) => string>;
+                    };
+                    validate: {
+                        type: import('../../../vue/dist/vue.esm-bundler.js').PropType<(value: string) => boolean>;
+                    };
+                    valueOnInvalidChange: {
+                        type: import('../../../vue/dist/vue.esm-bundler.js').PropType<boolean | ((inputValue: string, lastValidInputValue: string) => string)>;
+                    };
+                    showPasswordEvent: {
+                        type: import('../../../vue/dist/vue.esm-bundler.js').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;
+                }>, "type" | "color" | "variant" | "disabled" | "clear" | "blur" | "focus" | "clearable" | "readonly" | "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/dist/vue.esm-bundler.js').ComponentCustomProperties & {} & {
+                    $slots: Readonly<{
+                        default(): any;
+                        prepend(): any;
+                        append(): any;
+                        prefix(): any;
+                        suffix(): any;
+                    }> & {
+                        default(): any;
+                        prepend(): any;
+                        append(): any;
+                        prefix(): any;
+                        suffix(): any;
+                    };
+                }) | null;
+                uploadBtnRef: HTMLSpanElement;
+                fileInputRef: HTMLInputElement;
+            };
+            $slots: Readonly<{
+                [name: string]: import('../../../vue/dist/vue.esm-bundler.js').Slot<any> | undefined;
+            }>;
+            $root: import('../../../vue/dist/vue.esm-bundler.js').ComponentPublicInstance | null;
+            $parent: import('../../../vue/dist/vue.esm-bundler.js').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: (event: string, ...args: any[]) => void;
+            $el: HTMLDivElement;
+            $options: import('../../../vue/dist/vue.esm-bundler.js').ComponentOptionsBase<Readonly<import('./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/dist/vue.esm-bundler.js').ComponentOptionsMixin, import('../../../vue/dist/vue.esm-bundler.js').ComponentOptionsMixin, {
+                [x: string]: any;
+            } & {
+                [x: string]: any;
+            }, string, {
+                size: "small" | "medium" | "large";
+                disabled: boolean;
+                preview: boolean;
+                modelValue: string;
+                imageUrl: string;
+                enableImageSearch: boolean;
+                maxImageSize: number;
+                expanded: boolean;
+                clearable: boolean;
+                showSuffix: boolean;
+                inlineThumbnail: boolean;
+                allowedImageTypes: string[];
+            }, {}, string, {}, import('../../../vue/dist/vue.esm-bundler.js').GlobalComponents, import('../../../vue/dist/vue.esm-bundler.js').GlobalDirectives, string, import('../../../vue/dist/vue.esm-bundler.js').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/dist/vue.esm-bundler.js').DebuggerEvent) => void) | ((e: import('../../../vue/dist/vue.esm-bundler.js').DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import('../../../vue/dist/vue.esm-bundler.js').DebuggerEvent) => void) | ((e: import('../../../vue/dist/vue.esm-bundler.js').DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import('../../../vue/dist/vue.esm-bundler.js').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('../../../vue/dist/vue.esm-bundler.js').ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import('../../../vue/dist/vue.esm-bundler.js').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/dist/vue.esm-bundler.js').WatchOptions): import('../../../vue/dist/vue.esm-bundler.js').WatchStopHandle;
+        } & Readonly<{
+            size: "small" | "medium" | "large";
+            disabled: boolean;
+            preview: boolean;
+            modelValue: string;
+            imageUrl: string;
+            enableImageSearch: boolean;
+            maxImageSize: number;
+            expanded: boolean;
+            clearable: boolean;
+            showSuffix: boolean;
+            inlineThumbnail: boolean;
+            allowedImageTypes: string[];
+        }> & Omit<Readonly<import('./internal/SearchImageInput.vue').SearchImageInputPropsT> & Readonly<{
+            [x: `on${Capitalize<any>}`]: ((...args: any) => any) | undefined;
+        }>, "blur" | "focus" | "awaitUpload" | "getUploadedUrl" | "getIsUploading" | "resetImage" | ("size" | "disabled" | "preview" | "modelValue" | "imageUrl" | "enableImageSearch" | "maxImageSize" | "expanded" | "clearable" | "showSuffix" | "inlineThumbnail" | "allowedImageTypes")> & {
+            focus: () => void | undefined;
+            blur: () => void | undefined;
+            awaitUpload: () => Promise<void>;
+            getUploadedUrl: () => string;
+            getIsUploading: () => boolean;
+            resetImage: () => void;
+        } & {} & import('../../../vue/dist/vue.esm-bundler.js').ComponentCustomProperties & {} & {
+            $slots: {
+                prefix?(_: {}): any;
+                suffix?(_: {
+                    hasValue: boolean;
+                }): any;
+                preview?(_: {
+                    previewUrl: string;
+                    remove: () => void;
+                }): any;
+            };
+        }) | null;
+    }, HTMLDivElement, import('../../../vue/dist/vue.esm-bundler.js').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('./OSearchInput.vue').OSearchInputPropsT> & Readonly<{
+        [x: `on${Capitalize<any>}`]: ((...args: any) => any) | undefined;
+    }>, {
+        focus: () => void | undefined;
+        blur: () => void | undefined;
+        search: () => Promise<void>;
+        saveHistory: (val?: string) => void;
+    }, {}, {}, {}, {
+        size: "small" | "medium" | "large";
+        modelValue: string;
+        imageUrl: string;
+        enableImageSearch: boolean;
+        maxImageSize: number;
+        clearable: boolean;
+        onestepItems: import('./types').OSearchRecommendItem[];
+        suggestItems: import('./types').OSearchRecommendItem[];
+        historyItems: string[];
+        highlightKeyword: boolean;
+        showSuggestEmpty: boolean;
+        storageKey: string;
+        storeHistory: boolean;
+        maxHistoryCount: number;
+        debounce: number;
+        autoSaveHistory: boolean;
+        enableHistory: boolean;
+        suggestList: string[];
+        allowHtmlInSuggest: boolean;
+        closeOnSearch: boolean;
+        closeOnClickOutside: boolean;
+        openOnFocus: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('../../../vue/dist/vue.esm-bundler.js').ComponentOptionsBase<Readonly<import('./OSearchInput.vue').OSearchInputPropsT> & Readonly<{
+    [x: `on${Capitalize<any>}`]: ((...args: any) => any) | undefined;
+}>, {
+    focus: () => void | undefined;
+    blur: () => void | undefined;
+    search: () => Promise<void>;
+    saveHistory: (val?: string) => void;
+}, {}, {}, {}, import('../../../vue/dist/vue.esm-bundler.js').ComponentOptionsMixin, import('../../../vue/dist/vue.esm-bundler.js').ComponentOptionsMixin, {
+    [x: string]: any;
+} & {
+    [x: string]: any;
+}, string, {
+    size: "small" | "medium" | "large";
+    modelValue: string;
+    imageUrl: string;
+    enableImageSearch: boolean;
+    maxImageSize: number;
+    clearable: boolean;
+    onestepItems: import('./types').OSearchRecommendItem[];
+    suggestItems: import('./types').OSearchRecommendItem[];
+    historyItems: string[];
+    highlightKeyword: boolean;
+    showSuggestEmpty: boolean;
+    storageKey: string;
+    storeHistory: boolean;
+    maxHistoryCount: number;
+    debounce: number;
+    autoSaveHistory: boolean;
+    enableHistory: boolean;
+    suggestList: string[];
+    allowHtmlInSuggest: boolean;
+    closeOnSearch: boolean;
+    closeOnClickOutside: boolean;
+    openOnFocus: boolean;
+}, {}, string, {}, import('../../../vue/dist/vue.esm-bundler.js').GlobalComponents, import('../../../vue/dist/vue.esm-bundler.js').GlobalDirectives, string, import('../../../vue/dist/vue.esm-bundler.js').ComponentProvideOptions> & import('../../../vue/dist/vue.esm-bundler.js').VNodeProps & import('../../../vue/dist/vue.esm-bundler.js').AllowedComponentProps & import('../../../vue/dist/vue.esm-bundler.js').ComponentCustomProps & (new () => {
+    $slots: {
+        'input-prefix'?(_: {}): any;
+        'input-suffix'?(_: {
+            hasValue: boolean;
+        }): any;
+        'image-preview'?(_: {
+            previewUrl: string;
+            remove: () => void;
+        }): any;
+        dropdown?(_: {
+            keyword: string;
+        }): any;
+        'onestep-header'?(_: {
+            items: import('./types').OSearchRecommendItem[];
+        }): any;
+        'onestep-content'?(_: {
+            items: import('./types').OSearchRecommendItem[];
+            keyword: string;
+        }): any;
+        'suggest-header'?(_: {
+            items: import('./types').OSearchRecommendItem[];
+        }): any;
+        'suggest-content'?(_: {
+            items: import('./types').OSearchRecommendItem[];
+            keyword: string;
+        }): any;
+        'history-header'?(_: {
+            items: string[];
+        }): any;
+        'history-content'?(_: {
+            items: string[];
+        }): any;
+        'suggest-list'?(_: {
+            items: string[];
+        }): any;
+    };
+}) & {
+    install(app: App): void;
+};
+export { OSearchInput };
+export type { OSearchRecommendItem, OSearchPayload, OSearchImageUploadErrorPayload, OSearchUploadImageFn, OSearchItemClickType, OSearchHighlightPart, } from './types';