bkui-vue 0.0.1-beta.38 → 0.0.1-beta.381

package/lib/info-box/info-box.variable.css

@@ -0,0 +1,157 @@
+:root {
+  --bk-prefix: bk;
+  --popover-max-height: 216px;
+  --primary-color: #3a84ff;
+  --success-color: #2dcb56;
+  --warning-color: #ff9c01;
+  --danger-color: #ea3636;
+  --default-color: #63656e;
+  --gray-color: #979ba5;
+  --light-gray: #c4c6cc;
+  --white-color: white;
+  --whitesmoke-color: #fafbfd;
+  --disable-color: #dcdee5;
+  --font-size-base: 12px;
+  --font-size-medium: 14px;
+  --font-size-large: 16px;
+  --line-height-base: 16px;
+  --line-height-medium: 16px;
+  --line-height-large: 18px;
+  --component-size-small: 26px;
+  --component-size-base: 32px;
+  --component-size-large: 40px;
+  --border-width-base: 1px;
+  --border-style-base: solid;
+  --border-radius-base: 2px;
+  --border-style-color: var(--light-gray);
+  --input-disabled-bg: #fafbfd;
+  --input-disabled-border: var(--disable-color);
+  --input-height-base: var(--component-size-base);
+  --input-color: var(--default-color);
+  --input-bg: white;
+  --input-border-color: var(--light-gray);
+  --input-broder-radius: 3px;
+  --input-shadow-color: #a3c5fd;
+  --input-horizontal-padding: 10px;
+  --input-block-color: #f5f7fa;
+  --input-block-hover-color: #eaebf0;
+  --input-icon-size: var(--font-size-medium);
+  --input-maxlength-color: #979ba5;
+  --button-primary-hover-color: #5594fa;
+  --button-danger-hover-color: #ff5656;
+  --button-success-hover-color: #45e35f;
+  --button-warning-hover-color: #ffb848;
+  --button-default-hover-border-color: #979ba5;
+  --button-primary-active-color: #2c77f4;
+  --button-danger-active-color: #db2626;
+  --button-success-active-color: #1ab943;
+  --button-warning-active-color: #eb9000;
+  --button-selected-bg-color: #e1ecff;
+  --button-disabled-selected-bg-color: #f0f1f5;
+  --radio-font-color: #63656e;
+  --radio-active-color: #5594fa;
+  --radio-hover-border-color: #979ba5;
+  --radio-disabled-border: #dcdee5;
+  --radio-disabled-font-color: #c4c6cc;
+  --radio-distable-checked-bg: #fafbfd;
+  --radio-button-checked-bg: #e1ecff;
+  --fixed-navbar-background: #fff;
+  --fixed-navbar-boxshadow-color: rgba(0, 0, 0, 0.1);
+  --switch-default-color: #fff;
+  --switch-grey-color: #c4c6cc;
+  --breadcrumb-black-color: #979ba5;
+  --breadcrumb-primary-hover-color: #0082ff;
+  --breadcrumb-fn-main-color: #63656e;
+  --link-default-hover-color: #979ba5;
+  --link-primary-hover-color: #699df4;
+  --link-success-hover-color: #45e35f;
+  --link-warning-hover-color: #ffb848;
+  --link-danger-hover-color: #ff5656;
+  --link-default-disabled-color: #dcdee5;
+  --link-primary-disabled-color: #a3c5fd;
+  --link-success-disabled-color: #94f5a4;
+  --link-warning-disabled-color: #ffd695;
+  --link-danger-disabled-color: #fd9c9c;
+  --message-color: var(--default-color);
+  --message-primary-bg-color: #f0f8ff;
+  --message-primary-border-color: #e1ecff;
+  --message-primary-shadow-color: #e1e8f4;
+  --message-warning-bg-color: #fff4e2;
+  --message-warning-border-color: #ffe8c3;
+  --message-warning-shadow-color: #ede6db;
+  --message-success-bg-color: #f2fff4;
+  --message-success-border-color: #dcffe2;
+  --message-success-shadow-color: #cef0d7;
+  --message-danger-bg-color: #ffeded;
+  --message-danger-border-color: #ffdddd;
+  --message-danger-shadow-color: #f6dada;
+  --slider-default-bg: #dcdee5;
+  --slider-disable-bar-bg: #979ba5;
+  --menu-bg-color: #182132;
+  --submenu-bg-color: #151d2c;
+  --menu-active-bg-color: linear-gradient(90deg, #3f87ff 0%, #3a84ff 100%);
+  --menu-color: #96a2b9;
+  --menu-group-color: var(--default-color);
+  --menu-width: 260px;
+  --menu-collapse-width: 60px;
+  --menu-active-color: white;
+  --nav-header-bg-color: #182132;
+  --nav-bg-color: #182132;
+  --date-picker-disabled-bg: #fafbfd;
+  --date-picker-dropdown-mb: 4px;
+  --date-picker-dropdown-bg: #fff;
+  --table-bg-color: var(--white-color);
+  --table-border-color: #dcdee5;
+  --table-head-bg-color: #fafbfd;
+  --table-head-font-color: #313238;
+  --table-body-font-color: #575961;
+  --table-row-hover-bg-color: #f5f7fa;
+  --table-row-active-bg-color: #f0f1f5;
+  --cascader-panel-border-color: #dcdee5;
+  --cascader-panel-hover: #f5f7fa;
+  --cascader-panel-active: #e1ecff;
+  --cascader-panel-disabled-bg: #fff;
+  --search-select-focus-border-color: var(--primary-color);
+  --search-select-focus-color: #3c96ff;
+  --search-select-font-color: var(--default-color);
+  --search-select-placeholder-color: var(--light-gray);
+  --search-select-message-color: var(--danger-color);
+  --search-select-menu-border-color: var(--disable-color);
+}
+.bk-modal-wrapper.bk-info-wrapper {
+  width: 440px;
+}
+.bk-modal-wrapper.bk-info-wrapper.normal {
+  width: 440px;
+}
+.bk-modal-wrapper.bk-info-wrapper.small {
+  width: 400px;
+}
+.bk-modal-wrapper.bk-info-wrapper .bk-modal-body {
+  border-radius: 2px;
+}
+.bk-modal-wrapper.bk-info-wrapper .bk-dialog-header {
+  padding: 24px 24px 0;
+}
+.bk-modal-wrapper.bk-info-wrapper .bk-dialog-header .bk-dialog-title {
+  height: 27px;
+  margin: 15px 0 10px;
+}
+.bk-modal-wrapper.bk-info-wrapper .bk-modal-content {
+  height: 100%;
+  max-height: 100%;
+  min-height: 100%;
+  padding: 0 50px 10px;
+}
+.bk-modal-wrapper.bk-info-wrapper .bk-modal-content .bk-info-sub-title {
+  margin-bottom: 10px;
+  text-align: center;
+}
+.bk-modal-wrapper.bk-info-wrapper .bk-modal-footer {
+  padding: 0 65px 33px;
+  background-color: #fff;
+  border-top: none;
+}
+.bk-modal-wrapper.bk-info-wrapper .bk-modal-footer .bk-dialog-footer button {
+  min-width: 88px;
+}

package/lib/input/index.d.ts

@@ -0,0 +1,528 @@
+declare const BkInput: {
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            behavior: "simplicity" | "normal";
+            type: string;
+            disabled: boolean;
+            step: number;
+            placeholder: string;
+            prefix: string;
+            max: number;
+            min: number;
+            maxlength: number;
+            clearable: boolean;
+            readonly: boolean;
+            prefixIcon: string;
+            suffixIcon: string;
+            suffix: string;
+            showWordLimit: boolean;
+            showControl: boolean;
+            showClearOnlyHover: boolean;
+            precision: number;
+            rows: number;
+            selectReadonly: boolean;
+            withValidate: boolean;
+        }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+            type: import("vue-types").VueTypeValidableDef<string> & {
+                default: string;
+            } & {
+                default: string;
+            };
+            clearable: import("vue-types").VueTypeValidableDef<boolean> & {
+                default: boolean;
+            };
+            disabled: import("vue-types").VueTypeValidableDef<boolean> & {
+                default: boolean;
+            };
+            readonly: import("vue-types").VueTypeValidableDef<boolean> & {
+                default: boolean;
+            };
+            placeholder: import("vue-types").VueTypeValidableDef<string> & {
+                default: string;
+            } & {
+                default: string;
+            };
+            prefixIcon: import("vue-types").VueTypeValidableDef<string> & {
+                default: string;
+            };
+            suffixIcon: import("vue-types").VueTypeValidableDef<string> & {
+                default: string;
+            };
+            suffix: import("vue-types").VueTypeValidableDef<string> & {
+                default: string;
+            };
+            prefix: import("vue-types").VueTypeValidableDef<string> & {
+                default: string;
+            };
+            step: import("vue-types").VueTypeDef<number> & {
+                default: number;
+            };
+            max: import("vue-types").VueTypeDef<number> & {
+                default: number;
+            };
+            min: import("vue-types").VueTypeDef<number> & {
+                default: number;
+            };
+            maxlength: import("vue-types").VueTypeDef<number> & {
+                default: number;
+            };
+            behavior: import("vue-types").VueTypeDef<"simplicity" | "normal"> & {
+                default: "simplicity" | "normal";
+            };
+            showWordLimit: import("vue-types").VueTypeValidableDef<boolean> & {
+                default: boolean;
+            };
+            showControl: import("vue-types").VueTypeValidableDef<boolean> & {
+                default: boolean;
+            } & {
+                default: boolean;
+            };
+            showClearOnlyHover: import("vue-types").VueTypeValidableDef<boolean> & {
+                default: boolean;
+            } & {
+                default: boolean;
+            };
+            precision: import("vue-types").VueTypeValidableDef<number> & {
+                default: number;
+            } & {
+                default: number;
+            } & {
+                validator: import("vue-types/dist/types").ValidatorFunction<unknown>;
+            };
+            modelValue: import("vue-types").VueTypeDef<string | number>;
+            size: import("vue-types").VueTypeDef<"small" | "default" | "large">;
+            rows: import("vue-types").VueTypeValidableDef<number> & {
+                default: number;
+            };
+            selectReadonly: import("vue-types").VueTypeValidableDef<boolean> & {
+                default: boolean;
+            } & {
+                default: boolean;
+            };
+            withValidate: import("vue-types").VueTypeValidableDef<boolean> & {
+                default: boolean;
+            } & {
+                default: boolean;
+            };
+        }>> & {
+            onPaste?: (_value: any, _evt?: Event | KeyboardEvent) => any;
+            onCompositionend?: (evt: CompositionEvent) => any;
+            onCompositionstart?: (evt: CompositionEvent) => any;
+            onCompositionupdate?: (evt: CompositionEvent) => any;
+            onFocus?: (evt: FocusEvent) => any;
+            onBlur?: (evt: FocusEvent) => any;
+            onChange?: (_value: any, _evt?: Event | KeyboardEvent) => any;
+            onInput?: (_value: any, _evt?: Event | KeyboardEvent) => any;
+            onKeydown?: (_value: any, _evt?: Event | KeyboardEvent) => any;
+            onKeypress?: (_value: any, _evt?: Event | KeyboardEvent) => any;
+            onKeyup?: (_value: any, _evt?: Event | KeyboardEvent) => any;
+            onEnter?: (_value: any, _evt?: Event | KeyboardEvent) => any;
+            "onUpdate:modelValue"?: (_value: any, _evt?: Event | KeyboardEvent) => any;
+            onClear?: () => any;
+        } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "behavior" | "type" | "disabled" | "step" | "placeholder" | "prefix" | "max" | "min" | "maxlength" | "clearable" | "readonly" | "prefixIcon" | "suffixIcon" | "suffix" | "showWordLimit" | "showControl" | "showClearOnlyHover" | "precision" | "rows" | "selectReadonly" | "withValidate">;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot;
+        }>;
+        $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>;
+        $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>;
+        $emit: ((event: import("./input").EVENTS.UPDATE, _value: any, _evt?: Event | KeyboardEvent) => void) & ((event: import("./input").EVENTS.FOCUS, evt: FocusEvent) => void) & ((event: import("./input").EVENTS.BLUR, evt: FocusEvent) => void) & ((event: import("./input").EVENTS.CHANGE, _value: any, _evt?: Event | KeyboardEvent) => void) & ((event: import("./input").EVENTS.CLEAR) => void) & ((event: import("./input").EVENTS.INPUT, _value: any, _evt?: Event | KeyboardEvent) => void) & ((event: import("./input").EVENTS.KEYPRESS, _value: any, _evt?: Event | KeyboardEvent) => void) & ((event: import("./input").EVENTS.KEYDOWN, _value: any, _evt?: Event | KeyboardEvent) => void) & ((event: import("./input").EVENTS.KEYUP, _value: any, _evt?: Event | KeyboardEvent) => void) & ((event: import("./input").EVENTS.ENTER, _value: any, _evt?: Event | KeyboardEvent) => void) & ((event: import("./input").EVENTS.PASTE, _value: any, _evt?: Event | KeyboardEvent) => void) & ((event: import("./input").EVENTS.COMPOSITIONSTART, evt: CompositionEvent) => void) & ((event: import("./input").EVENTS.COMPOSITIONUPDATE, evt: CompositionEvent) => void) & ((event: import("./input").EVENTS.COMPOSITIONEND, evt: CompositionEvent) => void);
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+            type: import("vue-types").VueTypeValidableDef<string> & {
+                default: string;
+            } & {
+                default: string;
+            };
+            clearable: import("vue-types").VueTypeValidableDef<boolean> & {
+                default: boolean;
+            };
+            disabled: import("vue-types").VueTypeValidableDef<boolean> & {
+                default: boolean;
+            };
+            readonly: import("vue-types").VueTypeValidableDef<boolean> & {
+                default: boolean;
+            };
+            placeholder: import("vue-types").VueTypeValidableDef<string> & {
+                default: string;
+            } & {
+                default: string;
+            };
+            prefixIcon: import("vue-types").VueTypeValidableDef<string> & {
+                default: string;
+            };
+            suffixIcon: import("vue-types").VueTypeValidableDef<string> & {
+                default: string;
+            };
+            suffix: import("vue-types").VueTypeValidableDef<string> & {
+                default: string;
+            };
+            prefix: import("vue-types").VueTypeValidableDef<string> & {
+                default: string;
+            };
+            step: import("vue-types").VueTypeDef<number> & {
+                default: number;
+            };
+            max: import("vue-types").VueTypeDef<number> & {
+                default: number;
+            };
+            min: import("vue-types").VueTypeDef<number> & {
+                default: number;
+            };
+            maxlength: import("vue-types").VueTypeDef<number> & {
+                default: number;
+            };
+            behavior: import("vue-types").VueTypeDef<"simplicity" | "normal"> & {
+                default: "simplicity" | "normal";
+            };
+            showWordLimit: import("vue-types").VueTypeValidableDef<boolean> & {
+                default: boolean;
+            };
+            showControl: import("vue-types").VueTypeValidableDef<boolean> & {
+                default: boolean;
+            } & {
+                default: boolean;
+            };
+            showClearOnlyHover: import("vue-types").VueTypeValidableDef<boolean> & {
+                default: boolean;
+            } & {
+                default: boolean;
+            };
+            precision: import("vue-types").VueTypeValidableDef<number> & {
+                default: number;
+            } & {
+                default: number;
+            } & {
+                validator: import("vue-types/dist/types").ValidatorFunction<unknown>;
+            };
+            modelValue: import("vue-types").VueTypeDef<string | number>;
+            size: import("vue-types").VueTypeDef<"small" | "default" | "large">;
+            rows: import("vue-types").VueTypeValidableDef<number> & {
+                default: number;
+            };
+            selectReadonly: import("vue-types").VueTypeValidableDef<boolean> & {
+                default: boolean;
+            } & {
+                default: boolean;
+            };
+            withValidate: import("vue-types").VueTypeValidableDef<boolean> & {
+                default: boolean;
+            } & {
+                default: boolean;
+            };
+        }>> & {
+            onPaste?: (_value: any, _evt?: Event | KeyboardEvent) => any;
+            onCompositionend?: (evt: CompositionEvent) => any;
+            onCompositionstart?: (evt: CompositionEvent) => any;
+            onCompositionupdate?: (evt: CompositionEvent) => any;
+            onFocus?: (evt: FocusEvent) => any;
+            onBlur?: (evt: FocusEvent) => any;
+            onChange?: (_value: any, _evt?: Event | KeyboardEvent) => any;
+            onInput?: (_value: any, _evt?: Event | KeyboardEvent) => any;
+            onKeydown?: (_value: any, _evt?: Event | KeyboardEvent) => any;
+            onKeypress?: (_value: any, _evt?: Event | KeyboardEvent) => any;
+            onKeyup?: (_value: any, _evt?: Event | KeyboardEvent) => any;
+            onEnter?: (_value: any, _evt?: Event | KeyboardEvent) => any;
+            "onUpdate:modelValue"?: (_value: any, _evt?: Event | KeyboardEvent) => any;
+            onClear?: () => any;
+        }, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            "update:modelValue": (_value: any, _evt?: Event | KeyboardEvent) => boolean;
+            focus: (evt: FocusEvent) => FocusEvent;
+            blur: (evt: FocusEvent) => FocusEvent;
+            change: (_value: any, _evt?: Event | KeyboardEvent) => boolean;
+            clear: () => boolean;
+            input: (_value: any, _evt?: Event | KeyboardEvent) => boolean;
+            keypress: (_value: any, _evt?: Event | KeyboardEvent) => boolean;
+            keydown: (_value: any, _evt?: Event | KeyboardEvent) => boolean;
+            keyup: (_value: any, _evt?: Event | KeyboardEvent) => boolean;
+            enter: (_value: any, _evt?: Event | KeyboardEvent) => boolean;
+            paste: (_value: any, _evt?: Event | KeyboardEvent) => boolean;
+            compositionstart: (evt: CompositionEvent) => CompositionEvent;
+            compositionupdate: (evt: CompositionEvent) => CompositionEvent;
+            compositionend: (evt: CompositionEvent) => CompositionEvent;
+        }, string, {
+            behavior: "simplicity" | "normal";
+            type: string;
+            disabled: boolean;
+            step: number;
+            placeholder: string;
+            prefix: string;
+            max: number;
+            min: number;
+            maxlength: number;
+            clearable: boolean;
+            readonly: boolean;
+            prefixIcon: string;
+            suffixIcon: string;
+            suffix: string;
+            showWordLimit: boolean;
+            showControl: boolean;
+            showClearOnlyHover: boolean;
+            precision: number;
+            rows: number;
+            selectReadonly: boolean;
+            withValidate: boolean;
+        }> & {
+            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<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("vue").nextTick;
+        $watch(source: string | Function, cb: Function, options?: import("vue").WatchOptions<boolean>): import("vue").WatchStopHandle;
+    } & Readonly<import("vue").ExtractPropTypes<{
+        type: import("vue-types").VueTypeValidableDef<string> & {
+            default: string;
+        } & {
+            default: string;
+        };
+        clearable: import("vue-types").VueTypeValidableDef<boolean> & {
+            default: boolean;
+        };
+        disabled: import("vue-types").VueTypeValidableDef<boolean> & {
+            default: boolean;
+        };
+        readonly: import("vue-types").VueTypeValidableDef<boolean> & {
+            default: boolean;
+        };
+        placeholder: import("vue-types").VueTypeValidableDef<string> & {
+            default: string;
+        } & {
+            default: string;
+        };
+        prefixIcon: import("vue-types").VueTypeValidableDef<string> & {
+            default: string;
+        };
+        suffixIcon: import("vue-types").VueTypeValidableDef<string> & {
+            default: string;
+        };
+        suffix: import("vue-types").VueTypeValidableDef<string> & {
+            default: string;
+        };
+        prefix: import("vue-types").VueTypeValidableDef<string> & {
+            default: string;
+        };
+        step: import("vue-types").VueTypeDef<number> & {
+            default: number;
+        };
+        max: import("vue-types").VueTypeDef<number> & {
+            default: number;
+        };
+        min: import("vue-types").VueTypeDef<number> & {
+            default: number;
+        };
+        maxlength: import("vue-types").VueTypeDef<number> & {
+            default: number;
+        };
+        behavior: import("vue-types").VueTypeDef<"simplicity" | "normal"> & {
+            default: "simplicity" | "normal";
+        };
+        showWordLimit: import("vue-types").VueTypeValidableDef<boolean> & {
+            default: boolean;
+        };
+        showControl: import("vue-types").VueTypeValidableDef<boolean> & {
+            default: boolean;
+        } & {
+            default: boolean;
+        };
+        showClearOnlyHover: import("vue-types").VueTypeValidableDef<boolean> & {
+            default: boolean;
+        } & {
+            default: boolean;
+        };
+        precision: import("vue-types").VueTypeValidableDef<number> & {
+            default: number;
+        } & {
+            default: number;
+        } & {
+            validator: import("vue-types/dist/types").ValidatorFunction<unknown>;
+        };
+        modelValue: import("vue-types").VueTypeDef<string | number>;
+        size: import("vue-types").VueTypeDef<"small" | "default" | "large">;
+        rows: import("vue-types").VueTypeValidableDef<number> & {
+            default: number;
+        };
+        selectReadonly: import("vue-types").VueTypeValidableDef<boolean> & {
+            default: boolean;
+        } & {
+            default: boolean;
+        };
+        withValidate: import("vue-types").VueTypeValidableDef<boolean> & {
+            default: boolean;
+        } & {
+            default: boolean;
+        };
+    }>> & {
+        onPaste?: (_value: any, _evt?: Event | KeyboardEvent) => any;
+        onCompositionend?: (evt: CompositionEvent) => any;
+        onCompositionstart?: (evt: CompositionEvent) => any;
+        onCompositionupdate?: (evt: CompositionEvent) => any;
+        onFocus?: (evt: FocusEvent) => any;
+        onBlur?: (evt: FocusEvent) => any;
+        onChange?: (_value: any, _evt?: Event | KeyboardEvent) => any;
+        onInput?: (_value: any, _evt?: Event | KeyboardEvent) => any;
+        onKeydown?: (_value: any, _evt?: Event | KeyboardEvent) => any;
+        onKeypress?: (_value: any, _evt?: Event | KeyboardEvent) => any;
+        onKeyup?: (_value: any, _evt?: Event | KeyboardEvent) => any;
+        onEnter?: (_value: any, _evt?: Event | KeyboardEvent) => any;
+        "onUpdate:modelValue"?: (_value: any, _evt?: Event | KeyboardEvent) => any;
+        onClear?: () => any;
+    } & import("vue").ShallowUnwrapRef<() => JSX.Element> & {} & {} & import("vue").ComponentCustomProperties;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    type: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    } & {
+        default: string;
+    };
+    clearable: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    };
+    disabled: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    };
+    readonly: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    };
+    placeholder: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    } & {
+        default: string;
+    };
+    prefixIcon: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+    suffixIcon: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+    suffix: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+    prefix: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+    step: import("vue-types").VueTypeDef<number> & {
+        default: number;
+    };
+    max: import("vue-types").VueTypeDef<number> & {
+        default: number;
+    };
+    min: import("vue-types").VueTypeDef<number> & {
+        default: number;
+    };
+    maxlength: import("vue-types").VueTypeDef<number> & {
+        default: number;
+    };
+    behavior: import("vue-types").VueTypeDef<"simplicity" | "normal"> & {
+        default: "simplicity" | "normal";
+    };
+    showWordLimit: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    };
+    showControl: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    showClearOnlyHover: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    precision: import("vue-types").VueTypeValidableDef<number> & {
+        default: number;
+    } & {
+        default: number;
+    } & {
+        validator: import("vue-types/dist/types").ValidatorFunction<unknown>;
+    };
+    modelValue: import("vue-types").VueTypeDef<string | number>;
+    size: import("vue-types").VueTypeDef<"small" | "default" | "large">;
+    rows: import("vue-types").VueTypeValidableDef<number> & {
+        default: number;
+    };
+    selectReadonly: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    withValidate: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+}>> & {
+    onPaste?: (_value: any, _evt?: Event | KeyboardEvent) => any;
+    onCompositionend?: (evt: CompositionEvent) => any;
+    onCompositionstart?: (evt: CompositionEvent) => any;
+    onCompositionupdate?: (evt: CompositionEvent) => any;
+    onFocus?: (evt: FocusEvent) => any;
+    onBlur?: (evt: FocusEvent) => any;
+    onChange?: (_value: any, _evt?: Event | KeyboardEvent) => any;
+    onInput?: (_value: any, _evt?: Event | KeyboardEvent) => any;
+    onKeydown?: (_value: any, _evt?: Event | KeyboardEvent) => any;
+    onKeypress?: (_value: any, _evt?: Event | KeyboardEvent) => any;
+    onKeyup?: (_value: any, _evt?: Event | KeyboardEvent) => any;
+    onEnter?: (_value: any, _evt?: Event | KeyboardEvent) => any;
+    "onUpdate:modelValue"?: (_value: any, _evt?: Event | KeyboardEvent) => any;
+    onClear?: () => any;
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (_value: any, _evt?: Event | KeyboardEvent) => boolean;
+    focus: (evt: FocusEvent) => FocusEvent;
+    blur: (evt: FocusEvent) => FocusEvent;
+    change: (_value: any, _evt?: Event | KeyboardEvent) => boolean;
+    clear: () => boolean;
+    input: (_value: any, _evt?: Event | KeyboardEvent) => boolean;
+    keypress: (_value: any, _evt?: Event | KeyboardEvent) => boolean;
+    keydown: (_value: any, _evt?: Event | KeyboardEvent) => boolean;
+    keyup: (_value: any, _evt?: Event | KeyboardEvent) => boolean;
+    enter: (_value: any, _evt?: Event | KeyboardEvent) => boolean;
+    paste: (_value: any, _evt?: Event | KeyboardEvent) => boolean;
+    compositionstart: (evt: CompositionEvent) => CompositionEvent;
+    compositionupdate: (evt: CompositionEvent) => CompositionEvent;
+    compositionend: (evt: CompositionEvent) => CompositionEvent;
+}, string, {
+    behavior: "simplicity" | "normal";
+    type: string;
+    disabled: boolean;
+    step: number;
+    placeholder: string;
+    prefix: string;
+    max: number;
+    min: number;
+    maxlength: number;
+    clearable: boolean;
+    readonly: boolean;
+    prefixIcon: string;
+    suffixIcon: string;
+    suffix: string;
+    showWordLimit: boolean;
+    showControl: boolean;
+    showClearOnlyHover: boolean;
+    precision: number;
+    rows: number;
+    selectReadonly: boolean;
+    withValidate: boolean;
+}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("@vue/runtime-core").Plugin;
+export default BkInput;