yc-design-vue 2.1.8 → 2.2.0

package/es/Input/index.d.ts

@@ -1,6 +1,12 @@
 import { App } from 'vue';
 import { default as _Input } from './Input.vue';
+import { default as _InputSearch } from './InputSearch.vue';
+import { default as _InputPassword } from './InputPassword.vue';
+import { default as _InputGroup } from './InputGroup.vue';
 export type InputInstance = InstanceType<typeof _Input>;
+export type InputPasswordInstance = InstanceType<typeof _InputPassword>;
+export type InputSearchInstance = InstanceType<typeof _InputSearch>;
+export type InputGroupInstance = InstanceType<typeof _InputGroup>;
 export * from './type';
 declare const Input: {
     new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./type').InputProps> & Readonly<{
@@ -11,13 +17,13 @@ declare const Input: {
         onInput?: ((value: string, ev: Event) => any) | undefined;
         onKeydown?: ((ev: KeyboardEvent) => any) | undefined;
         "onUpdate:modelValue"?: ((value: string) => any) | undefined;
-        "onUpdate:visibility"?: ((value: boolean) => any) | undefined;
-        "onVisibility-change"?: ((value: boolean) => any) | undefined;
         onPressEnter?: ((ev: KeyboardEvent) => any) | undefined;
     }>, {
         focus(): void;
         blur(): void;
         getInputRef(): HTMLInputElement;
+        setCursor?: () => void;
+        recordCursor?: () => void;
     }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
         change: (value: string, ev: Event) => any;
         focus: (ev: FocusEvent) => any;
@@ -26,8 +32,6 @@ declare const Input: {
         input: (value: string, ev: Event) => any;
         keydown: (ev: KeyboardEvent) => any;
         "update:modelValue": (value: string) => any;
-        "update:visibility": (value: boolean) => any;
-        "visibility-change": (value: boolean) => any;
         pressEnter: (ev: KeyboardEvent) => any;
     }, import('vue').PublicProps, {
         error: boolean;
@@ -43,10 +47,6 @@ declare const Input: {
         wordLength: import('./type').WordLength;
         wordSlice: import('./type').WordSlice;
         inputAttrs: import('..').RecordType;
-        isPassword: boolean;
-        visibility: boolean;
-        defaultVisibility: boolean;
-        invisibleButton: boolean;
         showInput: boolean;
     }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
         inputRef: HTMLInputElement;
@@ -65,13 +65,13 @@ declare const Input: {
         onInput?: ((value: string, ev: Event) => any) | undefined;
         onKeydown?: ((ev: KeyboardEvent) => any) | undefined;
         "onUpdate:modelValue"?: ((value: string) => any) | undefined;
-        "onUpdate:visibility"?: ((value: boolean) => any) | undefined;
-        "onVisibility-change"?: ((value: boolean) => any) | undefined;
         onPressEnter?: ((ev: KeyboardEvent) => any) | undefined;
     }>, {
         focus(): void;
         blur(): void;
         getInputRef(): HTMLInputElement;
+        setCursor?: () => void;
+        recordCursor?: () => void;
     }, {}, {}, {}, {
         error: boolean;
         size: import('..').Size;
@@ -86,10 +86,6 @@ declare const Input: {
         wordLength: import('./type').WordLength;
         wordSlice: import('./type').WordSlice;
         inputAttrs: import('..').RecordType;
-        isPassword: boolean;
-        visibility: boolean;
-        defaultVisibility: boolean;
-        invisibleButton: boolean;
         showInput: boolean;
     }>;
     __isFragment?: never;
@@ -103,13 +99,13 @@ declare const Input: {
     onInput?: ((value: string, ev: Event) => any) | undefined;
     onKeydown?: ((ev: KeyboardEvent) => any) | undefined;
     "onUpdate:modelValue"?: ((value: string) => any) | undefined;
-    "onUpdate:visibility"?: ((value: boolean) => any) | undefined;
-    "onVisibility-change"?: ((value: boolean) => any) | undefined;
     onPressEnter?: ((ev: KeyboardEvent) => any) | undefined;
 }>, {
     focus(): void;
     blur(): void;
     getInputRef(): HTMLInputElement;
+    setCursor?: () => void;
+    recordCursor?: () => void;
 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
     change: (value: string, ev: Event) => any;
     focus: (ev: FocusEvent) => any;
@@ -118,8 +114,6 @@ declare const Input: {
     input: (value: string, ev: Event) => any;
     keydown: (ev: KeyboardEvent) => any;
     "update:modelValue": (value: string) => any;
-    "update:visibility": (value: boolean) => any;
-    "visibility-change": (value: boolean) => any;
     pressEnter: (ev: KeyboardEvent) => any;
 }, string, {
     error: boolean;
@@ -135,19 +129,442 @@ declare const Input: {
     wordLength: import('./type').WordLength;
     wordSlice: import('./type').WordSlice;
     inputAttrs: import('..').RecordType;
-    isPassword: boolean;
-    visibility: boolean;
-    defaultVisibility: boolean;
-    invisibleButton: boolean;
     showInput: boolean;
 }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
     $slots: any;
 }) & {
+    group: {
+        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, {}>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import('vue').ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+        $slots: {
+            default?(_: {}): any;
+        };
+    });
+    password: {
+        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./type').InputPasswordProps> & Readonly<{
+            "onUpdate:visibility"?: ((value: boolean) => any) | undefined;
+            "onVisibility-change"?: ((value: boolean) => any) | undefined;
+        }>, {
+            focus(): void;
+            blur(): void;
+            getInputRef(): HTMLInputElement;
+            setCursor?: () => void;
+            recordCursor?: () => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+            "update:visibility": (value: boolean) => any;
+            "visibility-change": (value: boolean) => any;
+        }, import('vue').PublicProps, {
+            visibility: boolean;
+            defaultVisibility: boolean;
+            invisibleButton: boolean;
+        }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+            inputRef: ({
+                $: import('vue').ComponentInternalInstance;
+                $data: {};
+                $props: {
+                    readonly modelValue?: string | undefined;
+                    readonly defaultValue?: string | undefined;
+                    readonly size?: import('..').Size | undefined;
+                    readonly allowClear?: boolean | undefined;
+                    readonly disabled?: boolean | undefined;
+                    readonly readonly?: boolean | undefined;
+                    readonly error?: boolean | undefined;
+                    readonly placeholder?: string | undefined;
+                    readonly maxLength?: import('./type').MaxLength | undefined;
+                    readonly wordLength?: import('./type').WordLength | undefined;
+                    readonly wordSlice?: import('./type').WordSlice | undefined;
+                    readonly showWordLimit?: boolean | undefined;
+                    readonly inputAttrs?: import('..').RecordType | undefined;
+                    readonly showInput?: boolean | undefined;
+                    readonly onChange?: ((value: string, ev: Event) => any) | undefined;
+                    readonly onFocus?: ((ev: FocusEvent) => any) | undefined;
+                    readonly onClear?: ((ev: MouseEvent) => any) | undefined;
+                    readonly onBlur?: ((ev: FocusEvent) => any) | undefined;
+                    readonly onInput?: ((value: string, ev: Event) => any) | undefined;
+                    readonly onKeydown?: ((ev: KeyboardEvent) => any) | undefined;
+                    readonly "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+                    readonly onPressEnter?: ((ev: KeyboardEvent) => any) | undefined;
+                } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+                $attrs: {
+                    [x: string]: unknown;
+                };
+                $refs: {
+                    [x: string]: unknown;
+                } & {
+                    inputRef: 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: "change", value: string, ev: Event) => void) & ((event: "focus", ev: FocusEvent) => void) & ((event: "clear", ev: MouseEvent) => void) & ((event: "blur", ev: FocusEvent) => void) & ((event: "input", value: string, ev: Event) => void) & ((event: "keydown", ev: KeyboardEvent) => void) & ((event: "update:modelValue", value: string) => void) & ((event: "pressEnter", ev: KeyboardEvent) => void);
+                $el: HTMLDivElement;
+                $options: import('vue').ComponentOptionsBase<Readonly<import('./type').InputProps> & Readonly<{
+                    onChange?: ((value: string, ev: Event) => any) | undefined;
+                    onFocus?: ((ev: FocusEvent) => any) | undefined;
+                    onClear?: ((ev: MouseEvent) => any) | undefined;
+                    onBlur?: ((ev: FocusEvent) => any) | undefined;
+                    onInput?: ((value: string, ev: Event) => any) | undefined;
+                    onKeydown?: ((ev: KeyboardEvent) => any) | undefined;
+                    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+                    onPressEnter?: ((ev: KeyboardEvent) => any) | undefined;
+                }>, {
+                    focus(): void;
+                    blur(): void;
+                    getInputRef(): HTMLInputElement;
+                    setCursor?: () => void;
+                    recordCursor?: () => void;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+                    change: (value: string, ev: Event) => any;
+                    focus: (ev: FocusEvent) => any;
+                    clear: (ev: MouseEvent) => any;
+                    blur: (ev: FocusEvent) => any;
+                    input: (value: string, ev: Event) => any;
+                    keydown: (ev: KeyboardEvent) => any;
+                    "update:modelValue": (value: string) => any;
+                    pressEnter: (ev: KeyboardEvent) => any;
+                }, string, {
+                    error: boolean;
+                    size: import('..').Size;
+                    disabled: boolean;
+                    placeholder: string;
+                    modelValue: string;
+                    defaultValue: string;
+                    maxLength: import('./type').MaxLength;
+                    showWordLimit: boolean;
+                    allowClear: boolean;
+                    readonly: boolean;
+                    wordLength: import('./type').WordLength;
+                    wordSlice: import('./type').WordSlice;
+                    inputAttrs: import('..').RecordType;
+                    showInput: 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<{
+                error: boolean;
+                size: import('..').Size;
+                disabled: boolean;
+                placeholder: string;
+                modelValue: string;
+                defaultValue: string;
+                maxLength: import('./type').MaxLength;
+                showWordLimit: boolean;
+                allowClear: boolean;
+                readonly: boolean;
+                wordLength: import('./type').WordLength;
+                wordSlice: import('./type').WordSlice;
+                inputAttrs: import('..').RecordType;
+                showInput: boolean;
+            }> & Omit<Readonly<import('./type').InputProps> & Readonly<{
+                onChange?: ((value: string, ev: Event) => any) | undefined;
+                onFocus?: ((ev: FocusEvent) => any) | undefined;
+                onClear?: ((ev: MouseEvent) => any) | undefined;
+                onBlur?: ((ev: FocusEvent) => any) | undefined;
+                onInput?: ((value: string, ev: Event) => any) | undefined;
+                onKeydown?: ((ev: KeyboardEvent) => any) | undefined;
+                "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+                onPressEnter?: ((ev: KeyboardEvent) => any) | undefined;
+            }>, "focus" | "blur" | "setCursor" | "recordCursor" | "getInputRef" | ("error" | "size" | "disabled" | "placeholder" | "modelValue" | "defaultValue" | "maxLength" | "showWordLimit" | "allowClear" | "readonly" | "wordLength" | "wordSlice" | "inputAttrs" | "showInput")> & import('vue').ShallowUnwrapRef<{
+                focus(): void;
+                blur(): void;
+                getInputRef(): HTMLInputElement;
+                setCursor?: () => void;
+                recordCursor?: () => void;
+            }> & {} & import('@vue/runtime-core').ComponentCustomProperties & {} & {
+                $slots: any;
+            }) | null;
+        }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import('./type').InputPasswordProps> & Readonly<{
+            "onUpdate:visibility"?: ((value: boolean) => any) | undefined;
+            "onVisibility-change"?: ((value: boolean) => any) | undefined;
+        }>, {
+            focus(): void;
+            blur(): void;
+            getInputRef(): HTMLInputElement;
+            setCursor?: () => void;
+            recordCursor?: () => void;
+        }, {}, {}, {}, {
+            visibility: boolean;
+            defaultVisibility: boolean;
+            invisibleButton: boolean;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import('vue').ComponentOptionsBase<Readonly<import('./type').InputPasswordProps> & Readonly<{
+        "onUpdate:visibility"?: ((value: boolean) => any) | undefined;
+        "onVisibility-change"?: ((value: boolean) => any) | undefined;
+    }>, {
+        focus(): void;
+        blur(): void;
+        getInputRef(): HTMLInputElement;
+        setCursor?: () => void;
+        recordCursor?: () => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        "update:visibility": (value: boolean) => any;
+        "visibility-change": (value: boolean) => any;
+    }, string, {
+        visibility: boolean;
+        defaultVisibility: boolean;
+        invisibleButton: boolean;
+    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+        $slots: {
+            prepend?(_: {}): any;
+            append?(_: {}): any;
+            prefix?(_: {}): any;
+            suffix?(_: {}): any;
+        };
+    });
+    search: {
+        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./type').InputSearchProps> & Readonly<{
+            onSearch?: ((value: string, ev: MouseEvent) => any) | undefined;
+        }>, {
+            focus(): void;
+            blur(): void;
+            getInputRef(): HTMLInputElement;
+            setCursor?: () => void;
+            recordCursor?: () => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+            search: (value: string, ev: MouseEvent) => any;
+        }, import('vue').PublicProps, {
+            size: import('..').Size;
+            disabled: boolean;
+            loading: boolean;
+            searchButton: boolean;
+            buttonText: string;
+            buttonProps: import('..').ButtonGroupProps;
+        }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+            inputRef: ({
+                $: import('vue').ComponentInternalInstance;
+                $data: {};
+                $props: {
+                    readonly modelValue?: string | undefined;
+                    readonly defaultValue?: string | undefined;
+                    readonly size?: import('..').Size | undefined;
+                    readonly allowClear?: boolean | undefined;
+                    readonly disabled?: boolean | undefined;
+                    readonly readonly?: boolean | undefined;
+                    readonly error?: boolean | undefined;
+                    readonly placeholder?: string | undefined;
+                    readonly maxLength?: import('./type').MaxLength | undefined;
+                    readonly wordLength?: import('./type').WordLength | undefined;
+                    readonly wordSlice?: import('./type').WordSlice | undefined;
+                    readonly showWordLimit?: boolean | undefined;
+                    readonly inputAttrs?: import('..').RecordType | undefined;
+                    readonly showInput?: boolean | undefined;
+                    readonly onChange?: ((value: string, ev: Event) => any) | undefined;
+                    readonly onFocus?: ((ev: FocusEvent) => any) | undefined;
+                    readonly onClear?: ((ev: MouseEvent) => any) | undefined;
+                    readonly onBlur?: ((ev: FocusEvent) => any) | undefined;
+                    readonly onInput?: ((value: string, ev: Event) => any) | undefined;
+                    readonly onKeydown?: ((ev: KeyboardEvent) => any) | undefined;
+                    readonly "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+                    readonly onPressEnter?: ((ev: KeyboardEvent) => any) | undefined;
+                } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+                $attrs: {
+                    [x: string]: unknown;
+                };
+                $refs: {
+                    [x: string]: unknown;
+                } & {
+                    inputRef: 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: "change", value: string, ev: Event) => void) & ((event: "focus", ev: FocusEvent) => void) & ((event: "clear", ev: MouseEvent) => void) & ((event: "blur", ev: FocusEvent) => void) & ((event: "input", value: string, ev: Event) => void) & ((event: "keydown", ev: KeyboardEvent) => void) & ((event: "update:modelValue", value: string) => void) & ((event: "pressEnter", ev: KeyboardEvent) => void);
+                $el: HTMLDivElement;
+                $options: import('vue').ComponentOptionsBase<Readonly<import('./type').InputProps> & Readonly<{
+                    onChange?: ((value: string, ev: Event) => any) | undefined;
+                    onFocus?: ((ev: FocusEvent) => any) | undefined;
+                    onClear?: ((ev: MouseEvent) => any) | undefined;
+                    onBlur?: ((ev: FocusEvent) => any) | undefined;
+                    onInput?: ((value: string, ev: Event) => any) | undefined;
+                    onKeydown?: ((ev: KeyboardEvent) => any) | undefined;
+                    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+                    onPressEnter?: ((ev: KeyboardEvent) => any) | undefined;
+                }>, {
+                    focus(): void;
+                    blur(): void;
+                    getInputRef(): HTMLInputElement;
+                    setCursor?: () => void;
+                    recordCursor?: () => void;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+                    change: (value: string, ev: Event) => any;
+                    focus: (ev: FocusEvent) => any;
+                    clear: (ev: MouseEvent) => any;
+                    blur: (ev: FocusEvent) => any;
+                    input: (value: string, ev: Event) => any;
+                    keydown: (ev: KeyboardEvent) => any;
+                    "update:modelValue": (value: string) => any;
+                    pressEnter: (ev: KeyboardEvent) => any;
+                }, string, {
+                    error: boolean;
+                    size: import('..').Size;
+                    disabled: boolean;
+                    placeholder: string;
+                    modelValue: string;
+                    defaultValue: string;
+                    maxLength: import('./type').MaxLength;
+                    showWordLimit: boolean;
+                    allowClear: boolean;
+                    readonly: boolean;
+                    wordLength: import('./type').WordLength;
+                    wordSlice: import('./type').WordSlice;
+                    inputAttrs: import('..').RecordType;
+                    showInput: 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<{
+                error: boolean;
+                size: import('..').Size;
+                disabled: boolean;
+                placeholder: string;
+                modelValue: string;
+                defaultValue: string;
+                maxLength: import('./type').MaxLength;
+                showWordLimit: boolean;
+                allowClear: boolean;
+                readonly: boolean;
+                wordLength: import('./type').WordLength;
+                wordSlice: import('./type').WordSlice;
+                inputAttrs: import('..').RecordType;
+                showInput: boolean;
+            }> & Omit<Readonly<import('./type').InputProps> & Readonly<{
+                onChange?: ((value: string, ev: Event) => any) | undefined;
+                onFocus?: ((ev: FocusEvent) => any) | undefined;
+                onClear?: ((ev: MouseEvent) => any) | undefined;
+                onBlur?: ((ev: FocusEvent) => any) | undefined;
+                onInput?: ((value: string, ev: Event) => any) | undefined;
+                onKeydown?: ((ev: KeyboardEvent) => any) | undefined;
+                "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+                onPressEnter?: ((ev: KeyboardEvent) => any) | undefined;
+            }>, "focus" | "blur" | "setCursor" | "recordCursor" | "getInputRef" | ("error" | "size" | "disabled" | "placeholder" | "modelValue" | "defaultValue" | "maxLength" | "showWordLimit" | "allowClear" | "readonly" | "wordLength" | "wordSlice" | "inputAttrs" | "showInput")> & import('vue').ShallowUnwrapRef<{
+                focus(): void;
+                blur(): void;
+                getInputRef(): HTMLInputElement;
+                setCursor?: () => void;
+                recordCursor?: () => void;
+            }> & {} & import('@vue/runtime-core').ComponentCustomProperties & {} & {
+                $slots: any;
+            }) | null;
+        }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import('./type').InputSearchProps> & Readonly<{
+            onSearch?: ((value: string, ev: MouseEvent) => any) | undefined;
+        }>, {
+            focus(): void;
+            blur(): void;
+            getInputRef(): HTMLInputElement;
+            setCursor?: () => void;
+            recordCursor?: () => void;
+        }, {}, {}, {}, {
+            size: import('..').Size;
+            disabled: boolean;
+            loading: boolean;
+            searchButton: boolean;
+            buttonText: string;
+            buttonProps: import('..').ButtonGroupProps;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import('vue').ComponentOptionsBase<Readonly<import('./type').InputSearchProps> & Readonly<{
+        onSearch?: ((value: string, ev: MouseEvent) => any) | undefined;
+    }>, {
+        focus(): void;
+        blur(): void;
+        getInputRef(): HTMLInputElement;
+        setCursor?: () => void;
+        recordCursor?: () => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        search: (value: string, ev: MouseEvent) => any;
+    }, string, {
+        size: import('..').Size;
+        disabled: boolean;
+        loading: boolean;
+        searchButton: boolean;
+        buttonText: string;
+        buttonProps: import('..').ButtonGroupProps;
+    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+        $slots: {
+            prepend?(_: {}): any;
+            append?(_: {}): any;
+            prefix?(_: {}): any;
+            suffix?(_: {}): any;
+        };
+    });
     install: (app: App) => void;
 };
+export { _InputGroup as InputGroup, _InputPassword as InputPassword, _InputSearch as InputSearch, };
 declare module 'vue' {
     interface GlobalComponents {
         YcInput: typeof Input;
+        YcInputGroup: typeof _InputGroup;
+        YcInputPassword: typeof _InputPassword;
+        YcInputSearch: typeof _InputSearch;
     }
 }
 export default Input;

package/es/Input/index.js

@@ -1,10 +1,23 @@
 import _sfc_main from "./Input.vue.js";
 /* empty css           */
+import _sfc_main$1 from "./InputSearch.vue.js";
+import _sfc_main$2 from "./InputPassword.vue.js";
+import _sfc_main$3 from "./InputGroup.vue.js";
+/* empty css                */
 const Input = Object.assign(_sfc_main, {
+  group: _sfc_main$3,
+  password: _sfc_main$2,
+  search: _sfc_main$1,
   install: (app) => {
     app.component("Yc" + _sfc_main.name, _sfc_main);
+    app.component("Yc" + _sfc_main$1.name, _sfc_main$1);
+    app.component("Yc" + _sfc_main$2.name, _sfc_main$2);
+    app.component("Yc" + _sfc_main$3.name, _sfc_main$3);
   }
 });
 export {
+  _sfc_main$3 as InputGroup,
+  _sfc_main$2 as InputPassword,
+  _sfc_main$1 as InputSearch,
   Input as default
 };

package/es/Input/type.d.ts

@@ -1,5 +1,6 @@
 import { VNode } from 'vue';
 import { Size, RecordType } from '../_shared/type';
+import { ButtonGroupProps } from '../Button';
 export interface InputProps {
     modelValue?: string;
     defaultValue?: string;
@@ -14,18 +15,12 @@ export interface InputProps {
     wordSlice?: WordSlice;
     showWordLimit?: boolean;
     inputAttrs?: RecordType;
-    isPassword?: boolean;
-    visibility?: boolean;
-    defaultVisibility?: boolean;
-    invisibleButton?: boolean;
     showInput?: boolean;
 }
 export interface InputEmits {
     (e: 'update:modelValue', value: string): void;
-    (e: 'update:visibility', value: boolean): void;
     (e: 'input', value: string, ev: Event): void;
     (e: 'change', value: string, ev: Event): void;
-    (e: 'visibility-change', value: boolean): void;
     (e: 'pressEnter', ev: KeyboardEvent): void;
     (e: 'keydown', ev: KeyboardEvent): void;
     (e: 'clear', ev: MouseEvent): void;
@@ -38,11 +33,34 @@ export interface InputSlots {
     prepend?: () => VNode[];
     append?: () => VNode[];
     label?: () => VNode[];
+    extra?: () => VNode[];
 }
 export interface InputExpose {
     focus(): void;
     blur(): void;
     getInputRef(): HTMLInputElement;
+    setCursor?: () => void;
+    recordCursor?: () => void;
+}
+export interface InputPasswordProps {
+    visibility?: boolean;
+    defaultVisibility?: boolean;
+    invisibleButton?: boolean;
+}
+export interface InputPasswordEmits {
+    (e: 'update:visibility', value: boolean): void;
+    (e: 'visibility-change', value: boolean): void;
+}
+export interface InputSearchProps {
+    searchButton?: boolean;
+    loading?: boolean;
+    disabled?: boolean;
+    size?: Size;
+    buttonText?: string;
+    buttonProps?: ButtonGroupProps;
+}
+export interface InputSearchEmits {
+    (e: 'search', value: string, ev: MouseEvent): void;
 }
 export type WordSlice = (value: string, maxLength: number) => string;
 export type WordLength = (value: string) => number;