cnhis-design-vue 3.1.38-beta.7 → 3.1.38

package/es/components/form-render/src/FormRender.vue.js

@@ -1,17 +1,16 @@
-import { defineComponent, computed, onMounted, ref, watch, openBlock, createBlock, unref, withCtx, createElementBlock, createVNode, isRef, Fragment, renderList, createCommentVNode, createElementVNode, normalizeStyle, withKeys, withModifiers, toDisplayString, nextTick } from 'vue';
-import { arrayed, findAncestor } from '../../../shared/utils/index.js';
-import { createForm, onFieldValueChange, isField } from '@formily/core';
-import { Path } from '@formily/path';
+import { defineComponent, computed, onMounted, ref, watch, onUnmounted, openBlock, createBlock, unref, withCtx, createElementBlock, createVNode, isRef, Fragment, renderList, createCommentVNode, createElementVNode, normalizeStyle, withKeys, withModifiers, toDisplayString } from 'vue';
+import { createForm, onFieldValueChange } from '@formily/core';
 import { FormProvider, FormConsumer } from '@formily/vue';
-import { isObject } from '@vue/shared';
-import { cloneDeep, isArray, isFunction } from 'lodash-es';
+import { cloneDeep } from 'lodash-es';
 import { NForm, NTabs, NTabPane, NConfigProvider } from 'naive-ui';
-import { NESTED_FORM_ITEM_TYPE, FormItemLineBarDepKeyPrepend } from './constants/index.js';
+import { useComplexOptionsSpan } from './hooks/useComplexOptions.js';
+import { useFormDomEvent, useFormExposeEvent } from './hooks/useFormEvent.js';
 import { useFormRenderLifeCycle } from './hooks/useFormRenderLifeCycle.js';
 import { useLowCodeReactions } from './hooks/useLowCodeReactions.js';
 import { useNuiThemeOverrides } from './hooks/useNuiThemeOverrides.js';
-import { validateMessageParser, combineExtendKey, splitExtendKey } from './utils/index.js';
+import './utils/index.js';
 import { useFieldListAdaptor } from './hooks/useFieldListAdaptor.js';
+import '../../../shared/utils/index.js';
 import '../index.js';
 import { useFieldVisitor } from './hooks/useFieldVisitor.js';
 import '../../../shared/utils/tapable/SyncHook.js';
@@ -30,15 +29,13 @@ import 'date-fns';
 import { useAnchor } from './hooks/useAnchor.js';
 import { useFormContext } from './hooks/useFormContext.js';
 import _export_sfc from '../../../_virtual/plugin-vue_export-helper.js';
-import { queryDecorator, queryInput, findNextWidget } from './utils/dom.js';
-import { createObjSchema, getParentLinebar } from './utils/schema.js';
+import { createObjSchema } from './utils/schema.js';
 
 const _hoisted_1 = {
   key: 0,
   style: { "height": "54px" }
 };
-const _hoisted_2 = ["onKeydownCapture"];
-const _hoisted_3 = { style: { "white-space": "pre" } };
+const _hoisted_2 = { style: { "white-space": "pre" } };
 const _sfc_main = /* @__PURE__ */ defineComponent({
   __name: "FormRender",
   props: {
@@ -127,110 +124,35 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       formItemDepsCollector
     );
     watch(parsedSchema, generateAnchorList, { immediate: true });
-    function onKeydown(event) {
-      var _a;
-      if (!props.enterToNextWidget || !formRenderRef.value)
-        return;
-      const ancestorFormItem = findAncestor(
-        event.target,
-        (ele) => ele.classList.contains("form-render__formItem")
-      );
-      if (!ancestorFormItem)
-        return;
-      const selector = `.form-render__formItem${NESTED_FORM_ITEM_TYPE.map((type) => `:not([widget-type=${type}])`).join("")}`;
-      const formItemElements = Array.from(formRenderRef.value.querySelectorAll(selector));
-      const formItemIndex = formItemElements.findIndex((ele) => ele.id === ancestorFormItem.id);
-      if (!~formItemIndex)
-        return;
-      const { widget, field } = findNextWidget(formItemElements, formItemIndex, event.target);
-      if (!widget)
-        return;
-      const formItemInstance = field && formModel.query(field).take();
-      if (formItemInstance && isFunction(props.enterToNextWidget)) {
-        props.enterToNextWidget((_a = formItemInstance.decoratorProps) == null ? void 0 : _a.fieldItem) ? focus() : onKeydown({ target: widget });
-      }
-      function focus() {
-        widget == null ? void 0 : widget.focus();
-      }
-    }
-    async function queryWidget(key, wrapperElement, fieldList) {
-      if (!formRenderRef.value)
-        return createResult();
-      const decoratorElement = queryDecorator(key, wrapperElement, formUUID);
-      if (decoratorElement)
-        return createResult(decoratorElement);
-      const parentLinebarKey = getParentLinebar(key, fieldList);
-      if (!parentLinebarKey)
-        return createResult();
-      formItemDepsCollector.trigger(FormItemLineBarDepKeyPrepend + parentLinebarKey, true);
-      await nextTick();
-      return createResult(queryDecorator(key, wrapperElement, formUUID));
-      function createResult(decoratorElement2) {
-        return { decoratorElement: decoratorElement2, ...queryInput(decoratorElement2) };
-      }
-    }
+    const { onKeydown } = useFormDomEvent({ formModel, formRenderRef, props });
+    const { clearSpan } = useComplexOptionsSpan();
+    onUnmounted(() => clearSpan(formUUID));
+    const exposeEvent = useFormExposeEvent({
+      formModel,
+      formRenderRef,
+      formItemDepsCollector,
+      getFieldList: () => _fieldList,
+      formUUID
+    });
     expose({
       formModel,
       validate(path = "*") {
-        return formModel.validate(path).catch((err) => {
-          return Promise.reject(Array.isArray(err) ? err.reduce(errInfoNormalize, []) : err);
-        });
-        function errInfoNormalize(result, error) {
-          if (!isObject(error))
-            return result;
-          let hasChildMessage = false;
-          if (isArray(error.messages)) {
-            error.messages.forEach((message) => {
-              if (!isObject(message))
-                return;
-              result.push(...arrayed(message).map(bindEleInfo));
-              hasChildMessage = true;
-            });
-          }
-          !hasChildMessage && result.push(bindEleInfo(error));
-          return result;
-        }
-        function bindEleInfo(info) {
-          if (info.decoratorElement)
-            return info;
-          const pattern = formModel.query(info.path);
-          const title = pattern.get("title");
-          const messages = info.messages.map(
-            (message) => errMessageNormalize(message, pattern.get("decoratorProps"))
-          );
-          const decoratorElement = queryDecorator(info.path, formRenderRef.value, formUUID);
-          return { ...info, messages, title, decoratorElement, ...queryInput(info.decoratorElement) };
-        }
-        function errMessageNormalize(message, decoratorProps) {
-          if (!decoratorProps || !decoratorProps.fieldItem)
-            return message;
-          return validateMessageParser(message, decoratorProps.fieldItem);
-        }
+        return exposeEvent.validate(path);
       },
-      getFormValues(needCombineExtendKey = true) {
-        const result = formModel.getFormState().values;
-        if (!needCombineExtendKey)
-          return result;
-        return combineExtendKey(_fieldList, result);
+      getFormValues(needCombineExtendKey = true, needCombineOptionKey = true) {
+        return exposeEvent.getFormValues(needCombineExtendKey, needCombineOptionKey);
       },
       setFormValues(values, needSplitExtendKey = true) {
-        if (needSplitExtendKey) {
-          values = splitExtendKey(_fieldList, values);
-        }
-        formModel.setFieldState("*", (state) => {
-          if (!isField(state))
-            return;
-          state.value = Path.getIn(values, state.path);
-        });
+        return exposeEvent.setFormValues(values, needSplitExtendKey);
       },
       setFieldState(path, handler) {
-        formModel.setFieldState(path, handler);
+        exposeEvent.setFieldState(path, handler);
       },
       resetFields(path = "*") {
-        formModel.reset(path);
+        exposeEvent.resetFields(path);
       },
       async queryWidget(key) {
-        return formRenderRef.value ? await queryWidget(key, formRenderRef.value, _fieldList) : null;
+        return exposeEvent.queryWidget(key);
       },
       async reload() {
         console.error("reload function is abstract,it should be overwrite!");
@@ -268,21 +190,24 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
                 ref_key: "formRenderRef",
                 ref: formRenderRef,
                 onScroll: _cache[1] || (_cache[1] = (...args) => unref(onScroll) && unref(onScroll)(...args)),
-                onKeydownCapture: withKeys(withModifiers(onKeydown, ["prevent"]), ["enter"])
+                onKeydownCapture: _cache[2] || (_cache[2] = withKeys(withModifiers(
+                  (...args) => unref(onKeydown) && unref(onKeydown)(...args),
+                  ["prevent"]
+                ), ["enter"]))
               }, [
                 createVNode(unref(FormProvider), { form: unref(formModel) }, {
                   default: withCtx(() => [
                     createVNode(unref(SchemaField), { schema: unref(parsedSchema) }, null, 8, ["schema"]),
                     __props.consumer ? (openBlock(), createBlock(unref(FormConsumer), { key: 0 }, {
                       default: withCtx(({ form }) => [
-                        createElementVNode("div", _hoisted_3, toDisplayString(JSON.stringify(form.values, null, 2)), 1)
+                        createElementVNode("div", _hoisted_2, toDisplayString(JSON.stringify(form.values, null, 2)), 1)
                       ]),
                       _: 1
                     })) : createCommentVNode("v-if", true)
                   ]),
                   _: 1
                 }, 8, ["form"])
-              ], 44, _hoisted_2)
+              ], 36)
             ]),
             _: 1
           }, 8, ["theme-overrides"])

package/es/components/form-render/src/FormRenderWrapper.vue.d.ts

@@ -452,15 +452,118 @@ declare const _default: import("vue").DefineComponent<{}, {
         formHeight: import("vue").ComputedRef<string | undefined>;
         onScroll: (scrollEvent: Event) => void;
         onKeydown: (event: KeyboardEvent) => void;
-        queryWidget: (key: string, wrapperElement: HTMLElement, fieldList: import("../../../../es/components/form-render").FieldItem[]) => Promise<{
-            widgetElement: HTMLInputElement | null | undefined;
-            widgetElementList: HTMLInputElement[];
-            decoratorElement: HTMLElement | null | undefined;
-        }>;
+        clearSpan: (uuid: string) => void;
+        exposeEvent: {
+            validate(path?: string): Promise<void>;
+            getFormValues(needCombineExtendKey?: boolean, needCombineOptionKey?: boolean): any;
+            setFormValues(values: import("../../../shared/types").AnyObject, needSplitExtendKey?: boolean): void;
+            setFieldState(path: string, handler: (field: Partial<Pick<import("../../../../es/components/form-render").Field<any, any, any, any>, import("../../../../es/components/form-render").NonFunctionPropertyNames<{
+                match: (pattern: import("@formily/path").Pattern) => boolean;
+                validate: (triggerType?: import("@formily/validator").ValidatorTriggerType | undefined) => any;
+                data: any;
+                loading: boolean;
+                required: boolean;
+                value: string;
+                readonly index: string | number;
+                disabled: boolean;
+                onFocus: (...args: any[]) => Promise<void>;
+                onBlur: (...args: any[]) => Promise<void>;
+                onInput: (...args: any[]) => Promise<void>;
+                reset: (options?: import("../../../../es/components/form-render").IFieldResetOptions | undefined) => Promise<void>;
+                visible: boolean;
+                submit: <T>(onSubmit?: ((values: any) => void | Promise<T>) | undefined) => Promise<T>;
+                validator: import("../../../../es/components/form-render").FieldValidator;
+                pattern: import("../../../../es/components/form-render").FieldPatternTypes;
+                title: string;
+                form: import("../../../../es/components/form-render").Form<any>;
+                content: any;
+                hidden: boolean;
+                active: boolean;
+                mounted: boolean;
+                readonly destroyed: boolean;
+                unmounted: boolean;
+                componentProps: Record<string, any>;
+                decoratorProps: Record<string, any>;
+                display: import("../../../../es/components/form-render").FieldDisplayTypes;
+                description: string;
+                readOnly: boolean;
+                editable: boolean;
+                component: import("../../../../es/components/form-render").FieldComponent<any, any>;
+                decorator: import("../../../../es/components/form-render").FieldDecorator<any, any>;
+                validating: boolean;
+                submitting: boolean;
+                visited: boolean;
+                selfModified: boolean;
+                modified: boolean;
+                inputValue: string;
+                inputValues: any[];
+                dataSource: import("../../../../es/components/form-render").FieldDataSource;
+                feedbacks: import("../../../../es/components/form-render").IFieldFeedback[];
+                caches: import("../../../../es/components/form-render").IFieldCaches;
+                selfErrors: import("../../../../es/components/form-render").FeedbackMessage;
+                readonly errors: import("../../../../es/components/form-render").IFormFeedback[];
+                selfWarnings: import("../../../../es/components/form-render").FeedbackMessage;
+                readonly warnings: import("../../../../es/components/form-render").IFormFeedback[];
+                selfSuccesses: import("../../../../es/components/form-render").FeedbackMessage;
+                readonly successes: import("../../../../es/components/form-render").IFormFeedback[];
+                readonly selfValid: boolean;
+                readonly valid: boolean;
+                readonly selfInvalid: boolean;
+                readonly invalid: boolean;
+                initialValue: string;
+                readonly validateStatus: "error" | "success" | "warning" | "validating";
+                setDataSource: (dataSource?: import("../../../../es/components/form-render").FieldDataSource | undefined) => void;
+                setFeedback: (feedback?: import("../../../../es/components/form-render").IFieldFeedback | undefined) => void;
+                setSelfErrors: (messages?: import("../../../../es/components/form-render").FeedbackMessage | undefined) => void;
+                setSelfWarnings: (messages?: import("../../../../es/components/form-render").FeedbackMessage | undefined) => void;
+                setSelfSuccesses: (messages?: import("../../../../es/components/form-render").FeedbackMessage | undefined) => void;
+                setValidator: (validator?: import("../../../../es/components/form-render").FieldValidator | undefined) => void;
+                setValidatorRule: (name: string, value: any) => void;
+                setRequired: (required?: boolean | undefined) => void;
+                setValue: (value?: string | undefined) => void;
+                setInitialValue: (initialValue?: string | undefined) => void;
+                setLoading: (loading?: boolean | undefined) => void;
+                setValidating: (validating?: boolean | undefined) => void;
+                setSubmitting: (submitting?: boolean | undefined) => void;
+                queryFeedbacks: (search?: import("../../../../es/components/form-render").ISearchFeedback | undefined) => import("../../../../es/components/form-render").IFieldFeedback[];
+                modify: () => void;
+                initialized: boolean;
+                decoratorType: any;
+                componentType: any;
+                designable: boolean;
+                locate: (address: import("@formily/path").Pattern) => void;
+                readonly parent: import("../../../../es/components/form-render").GeneralField;
+                readPretty: boolean;
+                setTitle: (title?: string | undefined) => void;
+                setDescription: (description?: string | undefined) => void;
+                setDisplay: (type?: import("../../../../es/components/form-render").FieldDisplayTypes | undefined) => void;
+                setPattern: (type?: import("../../../../es/components/form-render").FieldPatternTypes | undefined) => void;
+                setComponent: <C extends unknown, ComponentProps extends object = {}>(component?: C | undefined, props?: ComponentProps | undefined) => void;
+                setComponentProps: <ComponentProps_1 extends object = {}>(props?: ComponentProps_1 | undefined) => void;
+                setDecorator: <D extends unknown, ComponentProps_2 extends object = {}>(component?: D | undefined, props?: ComponentProps_2 | undefined) => void;
+                setDecoratorProps: <ComponentProps_3 extends object = {}>(props?: ComponentProps_3 | undefined) => void;
+                setData: (data: any) => void;
+                setContent: (content: any) => void;
+                onInit: () => void;
+                onMount: () => void;
+                onUnmount: () => void;
+                query: (pattern: import("@formily/path").Pattern) => import("../../../../es/components/form-render").Query;
+                notify: (type: import("../../../../es/components/form-render").LifeCycleTypes, payload?: any) => void;
+                dispose: () => void;
+                destroy: (forceClear?: boolean | undefined) => void;
+            }>>>) => void): void;
+            resetFields(path?: string): Promise<void>;
+            queryWidget(key: string): Promise<{
+                widgetElement: HTMLInputElement | null | undefined;
+                widgetElementList: HTMLInputElement[];
+                decoratorElement: HTMLElement | null | undefined;
+            } | null>;
+        };
         FormConsumer: import("vue").DefineComponent<{}, () => any, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
         FormProvider: import("vue").DefineComponent<Record<"form", any>, unknown, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<Record<"form", any>>>, {
             form: any;
         }>;
+        NConfigProvider: any;
         NForm: any;
         NTabPane: import("vue").DefineComponent<{
             readonly tab: import("vue").PropType<string | number | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
@@ -514,7 +617,6 @@ declare const _default: import("vue").DefineComponent<{}, {
             readonly displayDirective: "if" | "show" | "show:lazy";
         }>;
         NTabs: any;
-        NConfigProvider: any;
     }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("scroll" | "formChange" | "annotationChange")[], "scroll" | "formChange" | "annotationChange", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
         fieldList: {
             type: import("vue").PropType<import("../../../../es/components/form-render").FieldItem[]>;

package/es/components/form-render/src/components/renderer/formItem.js

@@ -10,8 +10,8 @@ import TooltipMessage from '../tooltipMessage.vue.js';
 import { InjectionAnnotation, InjectionFormUUID } from '../../constants/index.js';
 import { useComplexOptionsSpan } from '../../hooks/useComplexOptions.js';
 import { dotEscape } from '../../utils/schema.js';
-import { validateMessageParser } from '../../utils/index.js';
 import { useFormField } from '../../hooks/useFormField.js';
+import { validateMessageParser } from '../../utils/index.js';
 
 const script = defineComponent({
   props: {
@@ -83,12 +83,12 @@ const script = defineComponent({
       }, null)]) : null, showAnnotation.value ? renderAnnotation() : null]) : null]) : null;
     }
     const {
-      calcFieldItemSpan
+      getSpan
     } = useComplexOptionsSpan();
     return () => createVNode(NFormItem, mergeProps({
       "class": "form-render__formItem",
       "style": {
-        "--form-item-column": calcFieldItemSpan(props.span)
+        "--form-item-column": getSpan(uuid, field.value.address) + props.span
       }
     }, {
       id: id.value,

package/es/components/form-render/src/components/renderer/index.js

@@ -1,4 +1,3 @@
-import * as checkbox from './checkbox.js';
 import * as combination from './combination.js';
 import * as complex from './complex.js';
 import * as date from './date.js';
@@ -9,7 +8,7 @@ import * as inputNumber from './inputNumber.js';
 import * as index from './jsonCombination/index.js';
 import * as levelSearchCascader from './levelSearchCascader.js';
 import * as index$1 from './lineBar/index.js';
-import * as radio from './radio.js';
+import * as radio_checkbox from './radio_checkbox.js';
 import * as remoteSearch from './remoteSearch.js';
 import * as searchCascade from './searchCascade.js';
 import * as select from './select.js';
@@ -20,7 +19,6 @@ import * as textarea from './textarea.js';
 import { separateMetaModule } from '../../../../../shared/utils/index.js';
 
 const modules = Object.assign({
-  "./checkbox.tsx": checkbox,
   "./combination.tsx": combination,
   "./complex.tsx": complex,
   "./date.tsx": date,
@@ -31,7 +29,7 @@ const modules = Object.assign({
   "./jsonCombination/index.tsx": index,
   "./levelSearchCascader.tsx": levelSearchCascader,
   "./lineBar/index.ts": index$1,
-  "./radio.tsx": radio,
+  "./radio&checkbox.tsx": radio_checkbox,
   "./remoteSearch.tsx": remoteSearch,
   "./searchCascade.tsx": searchCascade,
   "./select.tsx": select,

package/es/components/form-render/src/components/renderer/radio&checkbox.d.ts

@@ -0,0 +1,186 @@
+import { AnyObject } from '../../../../../../es/shared/types';
+import { PropType } from 'vue';
+export declare const RADIO: import("vue").DefineComponent<{
+    value: {
+        type: (NumberConstructor | ObjectConstructor | StringConstructor)[];
+    };
+    options: {
+        type: PropType<AnyObject[]>;
+        default: () => never[];
+    };
+    autograph: {
+        type: StringConstructor;
+    };
+    lazyRequest: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    requestCache: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    wordbook: {
+        type: PropType<Partial<{
+            level_num: number;
+            id: string;
+            name: string;
+            render_key: string[];
+            search_key: string[];
+            primary_key: string;
+            type: string;
+            value_key: string;
+            level_key: string;
+            link_key: string;
+            link_key_split: string;
+            show_key: string[];
+            conObj: AnyObject[];
+            conObjFirstLevel: AnyObject[];
+        }>>;
+    };
+    vertical: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    onChange: {};
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:value"[], "update:value", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    value: {
+        type: (NumberConstructor | ObjectConstructor | StringConstructor)[];
+    };
+    options: {
+        type: PropType<AnyObject[]>;
+        default: () => never[];
+    };
+    autograph: {
+        type: StringConstructor;
+    };
+    lazyRequest: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    requestCache: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    wordbook: {
+        type: PropType<Partial<{
+            level_num: number;
+            id: string;
+            name: string;
+            render_key: string[];
+            search_key: string[];
+            primary_key: string;
+            type: string;
+            value_key: string;
+            level_key: string;
+            link_key: string;
+            link_key_split: string;
+            show_key: string[];
+            conObj: AnyObject[];
+            conObjFirstLevel: AnyObject[];
+        }>>;
+    };
+    vertical: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    onChange: {};
+}>> & {
+    "onUpdate:value"?: ((...args: any[]) => any) | undefined;
+}, {
+    options: AnyObject[];
+    vertical: boolean;
+    lazyRequest: boolean;
+    requestCache: boolean;
+}>;
+export declare const CHECKBOX: import("vue").DefineComponent<{
+    value: {
+        type: (NumberConstructor | ObjectConstructor | StringConstructor)[];
+    };
+    options: {
+        type: PropType<AnyObject[]>;
+        default: () => never[];
+    };
+    autograph: {
+        type: StringConstructor;
+    };
+    lazyRequest: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    requestCache: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    wordbook: {
+        type: PropType<Partial<{
+            level_num: number;
+            id: string;
+            name: string;
+            render_key: string[];
+            search_key: string[];
+            primary_key: string;
+            type: string;
+            value_key: string;
+            level_key: string;
+            link_key: string;
+            link_key_split: string;
+            show_key: string[];
+            conObj: AnyObject[];
+            conObjFirstLevel: AnyObject[];
+        }>>;
+    };
+    vertical: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    onChange: {};
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:value"[], "update:value", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    value: {
+        type: (NumberConstructor | ObjectConstructor | StringConstructor)[];
+    };
+    options: {
+        type: PropType<AnyObject[]>;
+        default: () => never[];
+    };
+    autograph: {
+        type: StringConstructor;
+    };
+    lazyRequest: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    requestCache: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    wordbook: {
+        type: PropType<Partial<{
+            level_num: number;
+            id: string;
+            name: string;
+            render_key: string[];
+            search_key: string[];
+            primary_key: string;
+            type: string;
+            value_key: string;
+            level_key: string;
+            link_key: string;
+            link_key_split: string;
+            show_key: string[];
+            conObj: AnyObject[];
+            conObjFirstLevel: AnyObject[];
+        }>>;
+    };
+    vertical: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    onChange: {};
+}>> & {
+    "onUpdate:value"?: ((...args: any[]) => any) | undefined;
+}, {
+    options: AnyObject[];
+    vertical: boolean;
+    lazyRequest: boolean;
+    requestCache: boolean;
+}>;