@opendesign-plus-test/components 0.0.1-rc.80 → 0.0.1-rc.81

package/dist/treeshaking/types/components/search/OSearchInput.vue.d.ts

@@ -0,0 +1,1025 @@
+import { OSearchRecommendItem, OSearchUploadImageFn } from './types';
+export interface OSearchInputPropsT {
+    modelValue?: string;
+    imageUrl?: string;
+    size?: 'small' | 'medium' | 'large';
+    placeholder?: string;
+    imagePlaceholder?: string;
+    /** ---- Image search ---- */
+    enableImageSearch?: boolean;
+    uploadImage?: OSearchUploadImageFn;
+    maxImageSize?: number;
+    imageUploadTooltip?: string;
+    allowedImageTypes?: string[];
+    /** ---- Recommendation lists (controlled by parent) ---- */
+    suggestItems?: OSearchRecommendItem[];
+    onestepItems?: OSearchRecommendItem[];
+    suggestTitle?: string;
+    onestepTitle?: string;
+    noDataText?: string;
+    /** When true, show "no data" placeholder for empty suggest while typing */
+    showSuggestEmpty?: boolean;
+    highlightKeyword?: boolean;
+    debounce?: number;
+    /** ---- History ---- */
+    enableHistory?: boolean;
+    historyItems?: string[];
+    maxHistoryCount?: number;
+    storeHistory?: boolean;
+    storageKey?: string;
+    historyTitle?: string;
+    /** Auto-record history on search; default true */
+    autoSaveHistory?: boolean;
+    /** ---- Hot searches (shown alongside history when no keyword) ---- */
+    hotItems?: string[];
+    hotTitle?: string;
+    /** ---- "Did you mean" list (below input) ---- */
+    suggestList?: string[];
+    suggestListLabel?: string;
+    /** ---- Misc ---- */
+    clearable?: boolean;
+    closeOnSearch?: boolean;
+    closeOnClickOutside?: boolean;
+    /** Show dropdown on focus even when empty (history) */
+    openOnFocus?: boolean;
+    /** Always show image as inline thumbnail inside the input; never expand preview below */
+    alwaysInlineThumbnail?: boolean;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        'input-prefix'?(_: {}): any;
+        'input-suffix'?(_: {
+            hasValue: boolean;
+        }): any;
+        'image-preview'?(_: {
+            previewUrl: string;
+            remove: () => void;
+        }): any;
+        dropdown?(_: {
+            keyword: string;
+        }): any;
+        'onestep-header'?(_: {
+            items: OSearchRecommendItem[];
+        }): any;
+        'onestep-content'?(_: {
+            items: OSearchRecommendItem[];
+            keyword: string;
+        }): any;
+        'suggest-header'?(_: {
+            items: OSearchRecommendItem[];
+        }): any;
+        'suggest-content'?(_: {
+            items: OSearchRecommendItem[];
+            keyword: string;
+        }): any;
+        'history-header'?(_: {
+            items: string[];
+        }): any;
+        'history-content'?(_: {
+            items: string[];
+        }): any;
+        'suggest-list'?(_: {
+            items: string[];
+        }): any;
+    };
+    refs: {
+        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?: 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;
+                        variant: "solid" | "outline" | "text";
+                        clearable: boolean;
+                        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 disabled: boolean;
+                        readonly readonly: boolean;
+                        readonly noKeyboard: boolean;
+                        readonly clearable: 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 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" | "readonly" | "noKeyboard" | "clearable" | "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: BooleanConstructor;
+                        };
+                        readonly: {
+                            type: BooleanConstructor;
+                        };
+                        noKeyboard: {
+                            type: BooleanConstructor;
+                        };
+                        clearable: {
+                            type: BooleanConstructor;
+                        };
+                        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;
+                        variant: "solid" | "outline" | "text";
+                        clearable: boolean;
+                        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;
+                    variant: "solid" | "outline" | "text";
+                    clearable: boolean;
+                    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: BooleanConstructor;
+                    };
+                    readonly: {
+                        type: BooleanConstructor;
+                    };
+                    noKeyboard: {
+                        type: BooleanConstructor;
+                    };
+                    clearable: {
+                        type: BooleanConstructor;
+                    };
+                    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" | "readonly" | "noKeyboard" | "clearable" | "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;
+                    }> & {
+                        default(): any;
+                        prepend(): any;
+                        append(): any;
+                        prefix(): any;
+                        suffix(): 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('./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;
+                modelValue: string;
+                clearable: boolean;
+                expanded: boolean;
+                preview: 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;
+            modelValue: string;
+            clearable: boolean;
+            expanded: boolean;
+            preview: boolean;
+            imageUrl: string;
+            enableImageSearch: boolean;
+            maxImageSize: number;
+            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" | "modelValue" | "clearable" | "expanded" | "preview" | "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;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<OSearchInputPropsT, {
+    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, import('vue').PublicProps, Readonly<OSearchInputPropsT> & Readonly<{
+    [x: `on${Capitalize<any>}`]: ((...args: any) => any) | undefined;
+}>, {
+    size: "small" | "medium" | "large";
+    modelValue: string;
+    clearable: boolean;
+    debounce: number;
+    imageUrl: string;
+    enableImageSearch: boolean;
+    maxImageSize: number;
+    onestepItems: OSearchRecommendItem[];
+    suggestItems: 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').ComponentProvideOptions, false, {
+    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?: 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;
+                    variant: "solid" | "outline" | "text";
+                    clearable: boolean;
+                    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 disabled: boolean;
+                    readonly readonly: boolean;
+                    readonly noKeyboard: boolean;
+                    readonly clearable: 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 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" | "readonly" | "noKeyboard" | "clearable" | "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: BooleanConstructor;
+                    };
+                    readonly: {
+                        type: BooleanConstructor;
+                    };
+                    noKeyboard: {
+                        type: BooleanConstructor;
+                    };
+                    clearable: {
+                        type: BooleanConstructor;
+                    };
+                    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;
+                    variant: "solid" | "outline" | "text";
+                    clearable: boolean;
+                    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;
+                variant: "solid" | "outline" | "text";
+                clearable: boolean;
+                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: BooleanConstructor;
+                };
+                readonly: {
+                    type: BooleanConstructor;
+                };
+                noKeyboard: {
+                    type: BooleanConstructor;
+                };
+                clearable: {
+                    type: BooleanConstructor;
+                };
+                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" | "readonly" | "noKeyboard" | "clearable" | "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;
+                }> & {
+                    default(): any;
+                    prepend(): any;
+                    append(): any;
+                    prefix(): any;
+                    suffix(): 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('./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;
+            modelValue: string;
+            clearable: boolean;
+            expanded: boolean;
+            preview: 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;
+        modelValue: string;
+        clearable: boolean;
+        expanded: boolean;
+        preview: boolean;
+        imageUrl: string;
+        enableImageSearch: boolean;
+        maxImageSize: number;
+        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" | "modelValue" | "clearable" | "expanded" | "preview" | "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;
+}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};