cnhis-design-vue 3.1.24-beta.7 → 3.1.24-beta.8

package/es/components/scale-view/src/components/AnswerParse.js

@@ -0,0 +1,80 @@
+import { defineComponent, computed, openBlock, createElementBlock, normalizeClass, unref, createElementVNode, createVNode, createTextVNode, toDisplayString, createCommentVNode } from 'vue';
+import script from '../../../../shared/components/SvgIcon/SvgIcon.js';
+import _export_sfc from '../../../../_virtual/plugin-vue_export-helper.js';
+
+const _hoisted_1 = { class: "answer-res-wrap" };
+const _hoisted_2 = { class: "answer-res" };
+const _hoisted_3 = { key: 0 };
+const _hoisted_4 = {
+  key: 0,
+  class: "correct-answer"
+};
+const _hoisted_5 = /* @__PURE__ */ createElementVNode("p", null, "\u6B63\u786E\u7B54\u6848\uFF1A", -1);
+const _hoisted_6 = { class: "answer-key" };
+const _hoisted_7 = /* @__PURE__ */ createElementVNode("p", null, "\u7B54\u6848\u89E3\u6790\uFF1A", -1);
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "AnswerParse",
+  props: {
+    item: { type: Object, default: () => ({}) }
+  },
+  setup(__props) {
+    const props = __props;
+    const questionScore = computed(() => {
+      var _a;
+      return ((_a = props.item) == null ? void 0 : _a.questionScore) || 0;
+    });
+    const answerSuccess = computed(() => {
+      var _a;
+      return ((_a = props.item) == null ? void 0 : _a.questionScore) > 0;
+    });
+    const answerIcon = computed(() => {
+      return answerSuccess.value ? "xitongtubiaodui" : "xitongtubiaocuo";
+    });
+    const answerResText = computed(() => {
+      if ("questionPartScore" in props.item) {
+        return "\u90E8\u5206\u6B63\u786E";
+      }
+      return answerSuccess.value ? "\u56DE\u7B54\u6B63\u786E" : "\u56DE\u7B54\u9519\u8BEF";
+    });
+    const scoreText = computed(() => {
+      if ("questionPartScore" in props.item) {
+        return "\u90E8\u5206";
+      }
+      return "\u672C\u9898";
+    });
+    const correctAnswer = computed(() => {
+      var _a;
+      let { correctAnswer: correctAnswer2 } = ((_a = props.item) == null ? void 0 : _a.scoreConfigs) || {};
+      return correctAnswer2;
+    });
+    const answerKeyText = computed(() => {
+      var _a;
+      let { answerKey } = ((_a = props.item) == null ? void 0 : _a.scoreConfigs) || {};
+      return answerKey || "\u65E0";
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["c-answerParse", { "answerParse-success": unref(answerSuccess) }])
+      }, [
+        createElementVNode("div", _hoisted_1, [
+          createElementVNode("div", _hoisted_2, [
+            createVNode(unref(script), { iconClass: unref(answerIcon) }, null, 8, ["iconClass"]),
+            createTextVNode(" " + toDisplayString(unref(answerResText)), 1)
+          ]),
+          unref(answerSuccess) ? (openBlock(), createElementBlock("div", _hoisted_3, toDisplayString(unref(scoreText)) + "\u5F97\u5206\uFF1A" + toDisplayString(unref(questionScore)) + "\u5206", 1)) : createCommentVNode("v-if", true)
+        ]),
+        unref(correctAnswer) ? (openBlock(), createElementBlock("div", _hoisted_4, [
+          _hoisted_5,
+          createElementVNode("span", null, toDisplayString(unref(correctAnswer)), 1)
+        ])) : createCommentVNode("v-if", true),
+        createElementVNode("div", _hoisted_6, [
+          _hoisted_7,
+          createElementVNode("span", null, toDisplayString(unref(answerKeyText)), 1)
+        ])
+      ], 2);
+    };
+  }
+});
+var AnswerParse = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "AnswerParse.vue"]]);
+
+export { AnswerParse as default };

package/es/components/scale-view/src/components/AnswerParse.vue.d.ts

@@ -0,0 +1,70 @@
+declare const _default: import("vue").DefineComponent<{
+    item: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+}, {
+    props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+        item: {
+            type: ObjectConstructor;
+            default: () => {};
+        };
+    }>> & {}>>;
+    questionScore: import("vue").ComputedRef<any>;
+    answerSuccess: import("vue").ComputedRef<boolean>;
+    answerIcon: import("vue").ComputedRef<"xitongtubiaodui" | "xitongtubiaocuo">;
+    answerResText: import("vue").ComputedRef<"部分正确" | "回答正确" | "回答错误">;
+    scoreText: import("vue").ComputedRef<"部分" | "本题">;
+    correctAnswer: import("vue").ComputedRef<any>;
+    answerKeyText: import("vue").ComputedRef<any>;
+    SvgIcon: import("vue").DefineComponent<{
+        iconClass: {
+            type: StringConstructor;
+            required: true;
+            default: string;
+        };
+        title: {
+            type: StringConstructor;
+            required: false;
+            default: string;
+        };
+        className: {
+            type: StringConstructor;
+            required: false;
+        };
+    }, {
+        props: {
+            iconClass: string;
+            title: string;
+            className?: string | undefined;
+        };
+        iconName: import("vue").ComputedRef<string>;
+        svgClass: import("vue").ComputedRef<string>;
+    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+        iconClass: {
+            type: StringConstructor;
+            required: true;
+            default: string;
+        };
+        title: {
+            type: StringConstructor;
+            required: false;
+            default: string;
+        };
+        className: {
+            type: StringConstructor;
+            required: false;
+        };
+    }>>, {
+        title: string;
+        iconClass: string;
+    }>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    item: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+}>>, {
+    item: Record<string, any>;
+}>;
+export default _default;

package/es/components/scale-view/src/components/EvaluateCountdown.js

@@ -0,0 +1,117 @@
+import { defineComponent, reactive, onMounted, watch, openBlock, createElementBlock, normalizeClass, unref, createElementVNode, toDisplayString, createVNode, createCommentVNode, createTextVNode } from 'vue';
+import { useEvaluate } from '../hooks/use-evaluate.js';
+import moment from 'moment';
+import script from '../../../../shared/components/SvgIcon/SvgIcon.js';
+import _export_sfc from '../../../../_virtual/plugin-vue_export-helper.js';
+
+const _hoisted_1 = { class: "answered-wrap" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "EvaluateCountdown",
+  props: {
+    formArray: { type: Array, default: () => [] },
+    evaluateResultConfig: { type: Object, default: () => ({}) },
+    evaluateResultSetting: { type: Object, default: () => ({}) },
+    form: { type: Object, default: () => ({}) },
+    currentTime: { default: new Date().getTime() },
+    showEvaluateCountdown: { type: Boolean, default: false }
+  },
+  emits: ["closeEvaluateCountdown"],
+  setup(__props, { expose, emit }) {
+    const props = __props;
+    const state = reactive({
+      source: "countdown",
+      setAnswered: 0
+    });
+    const { evaluateState, evaluateStartTime, showCountdown, getTotalLen, countdown, clearTimer } = useEvaluate(
+      props,
+      state,
+      { emit }
+    );
+    const init = () => {
+      getTotalLen();
+      let { evaluateTime } = props.evaluateResultSetting;
+      if (!showCountdown.value || !evaluateTime)
+        return;
+      let startTime = evaluateStartTime.value ? moment(evaluateStartTime.value) : moment();
+      let rangTime = startTime.add(evaluateTime, "minutes");
+      clearTimer();
+      countdown(rangTime);
+    };
+    const checkType = (val) => {
+      return Object.prototype.toString.call(val);
+    };
+    const diffAnswered = (form) => {
+      var _a;
+      let useFormArray = (_a = props.formArray) == null ? void 0 : _a.filter((item) => !evaluateState.filterArr.includes(item.type));
+      if (!useFormArray || !useFormArray.length)
+        return;
+      let useForm = {};
+      useFormArray.forEach((item) => {
+        const key = item.databaseTitle || item.title;
+        useForm[key] = form[key];
+      });
+      console.log(useForm);
+      let num = 0;
+      for (let key in useForm) {
+        let value = useForm[key];
+        let type = checkType(value);
+        if (type == "[object Object]") {
+          if (value && Object.keys(value).length)
+            num++;
+        } else if (type == "[object Array]") {
+          if (value && value.length)
+            num++;
+        } else if (type == "[object Number]") {
+          if (value || value === 0)
+            num++;
+        } else {
+          if (value)
+            num++;
+        }
+      }
+      state.setAnswered = num;
+    };
+    onMounted(() => {
+      init();
+    });
+    watch(
+      () => props.form,
+      (val) => {
+        if (!val && !Object.keys(val).length)
+          return;
+        console.log(val, "\u89E6\u53D1\u4FEE\u6539\u5566\u5566\u5566");
+        diffAnswered(val);
+      },
+      { immediate: true, deep: true }
+    );
+    const getCountdownObj = () => {
+      return {
+        setAnswered: state.setAnswered,
+        totalLen: evaluateState.totalLen
+      };
+    };
+    expose({
+      getCountdownObj
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["c-evaluateCountdown", { "evaluateCountdown-hasTime": props.showEvaluateCountdown }])
+      }, [
+        props.showEvaluateCountdown ? (openBlock(), createElementBlock("div", {
+          key: 0,
+          class: normalizeClass(["countdown", { "countdown-red": unref(evaluateState).countdownRed }])
+        }, [
+          createElementVNode("span", null, toDisplayString(unref(evaluateState).countdownStr), 1),
+          createVNode(unref(script), { "icon-class": "zhongtai-zujianliebiao-gongzuoshijian" })
+        ], 2)) : createCommentVNode("v-if", true),
+        createElementVNode("div", _hoisted_1, [
+          createTextVNode(" \u7B54\u9898\u60C5\u51B5\uFF1A " + toDisplayString(state.setAnswered) + "/ ", 1),
+          createElementVNode("span", null, toDisplayString(unref(evaluateState).totalLen), 1)
+        ])
+      ], 2);
+    };
+  }
+});
+var EvaluateCountdown = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "EvaluateCountdown.vue"]]);
+
+export { EvaluateCountdown as default };

package/es/components/scale-view/src/components/EvaluateCountdown.vue.d.ts

@@ -0,0 +1,154 @@
+declare const _default: import("vue").DefineComponent<{
+    formArray: {
+        type: ArrayConstructor;
+        default: () => never[];
+    };
+    evaluateResultConfig: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    evaluateResultSetting: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    form: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    currentTime: {
+        default: number;
+    };
+    showEvaluateCountdown: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {
+    state: {
+        source: string;
+        setAnswered: number;
+    };
+    props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+        formArray: {
+            type: ArrayConstructor;
+            default: () => never[];
+        };
+        evaluateResultConfig: {
+            type: ObjectConstructor;
+            default: () => {};
+        };
+        evaluateResultSetting: {
+            type: ObjectConstructor;
+            default: () => {};
+        };
+        form: {
+            type: ObjectConstructor;
+            default: () => {};
+        };
+        currentTime: {
+            default: number;
+        };
+        showEvaluateCountdown: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & {
+        onCloseEvaluateCountdown?: ((...args: any[]) => any) | undefined;
+    }>>;
+    emit: (event: "closeEvaluateCountdown", ...args: any[]) => void;
+    evaluateState: {
+        totalLen: number;
+        timer: null;
+        countdownStr: string;
+        isTimeOut: boolean;
+        countdownRed: boolean;
+        filterArr: string[];
+    };
+    evaluateStartTime: any;
+    showCountdown: import("vue").ComputedRef<any>;
+    getTotalLen: () => void;
+    countdown: (startTime: any) => void;
+    clearTimer: () => void;
+    init: () => void;
+    checkType: (val: any) => string;
+    diffAnswered: (form: any) => void;
+    getCountdownObj: () => {
+        setAnswered: number;
+        totalLen: number;
+    };
+    SvgIcon: import("vue").DefineComponent<{
+        iconClass: {
+            type: StringConstructor;
+            required: true;
+            default: string;
+        };
+        title: {
+            type: StringConstructor;
+            required: false;
+            default: string;
+        };
+        className: {
+            type: StringConstructor;
+            required: false;
+        };
+    }, {
+        props: {
+            iconClass: string;
+            title: string;
+            className?: string | undefined;
+        };
+        iconName: import("vue").ComputedRef<string>;
+        svgClass: import("vue").ComputedRef<string>;
+    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+        iconClass: {
+            type: StringConstructor;
+            required: true;
+            default: string;
+        };
+        title: {
+            type: StringConstructor;
+            required: false;
+            default: string;
+        };
+        className: {
+            type: StringConstructor;
+            required: false;
+        };
+    }>>, {
+        title: string;
+        iconClass: string;
+    }>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "closeEvaluateCountdown"[], "closeEvaluateCountdown", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    formArray: {
+        type: ArrayConstructor;
+        default: () => never[];
+    };
+    evaluateResultConfig: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    evaluateResultSetting: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    form: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    currentTime: {
+        default: number;
+    };
+    showEvaluateCountdown: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & {
+    onCloseEvaluateCountdown?: ((...args: any[]) => any) | undefined;
+}, {
+    formArray: unknown[];
+    evaluateResultConfig: Record<string, any>;
+    evaluateResultSetting: Record<string, any>;
+    form: Record<string, any>;
+    currentTime: number;
+    showEvaluateCountdown: boolean;
+}>;
+export default _default;

package/es/components/scale-view/src/components/EvaluatePage.js

@@ -0,0 +1,141 @@
+import { defineComponent, reactive, onMounted, openBlock, createElementBlock, createElementVNode, toDisplayString, createCommentVNode, unref, createVNode, withCtx, createTextVNode, Fragment } from 'vue';
+import { useEvaluate } from '../hooks/use-evaluate.js';
+import moment from 'moment';
+import { NButton } from 'naive-ui';
+import _export_sfc from '../../../../_virtual/plugin-vue_export-helper.js';
+
+const _hoisted_1 = { class: "c-evaluate-page" };
+const _hoisted_2 = { class: "evaluate-container" };
+const _hoisted_3 = {
+  key: 0,
+  class: "evaluate-name"
+};
+const _hoisted_4 = {
+  key: 1,
+  class: "evaluate-explain"
+};
+const _hoisted_5 = { class: "evaluate-score" };
+const _hoisted_6 = /* @__PURE__ */ createElementVNode("span", null, "\u6D4B\u8BC4\u603B\u9898", -1);
+const _hoisted_7 = /* @__PURE__ */ createElementVNode("span", null, "\u6D4B\u8BC4\u603B\u5206", -1);
+const _hoisted_8 = { key: 0 };
+const _hoisted_9 = /* @__PURE__ */ createElementVNode("span", null, "\u6D4B\u8BD5\u65F6\u95F4(\u5206\u949F)", -1);
+const _hoisted_10 = {
+  key: 2,
+  class: "evaluate-time-range"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "EvaluatePage",
+  props: {
+    formArray: { type: Array, default: () => [] },
+    evaluateResultConfig: { type: Object, default: () => ({}) },
+    evaluateResultSetting: { type: Object, default: () => ({}) },
+    isFinished: { type: Boolean, default: false },
+    maxScore: { type: Number, default: 0 }
+  },
+  emits: ["writeGuage", "closeEvaluateCountdown"],
+  setup(__props, { emit }) {
+    const props = __props;
+    const state = reactive({
+      source: "page",
+      timer: null,
+      curTime: new Date().getTime(),
+      timeRange: "",
+      banStart: false
+    });
+    const {
+      evaluateState,
+      evaluateStartTime,
+      getEvaluateTime,
+      getEvaluateStartTime,
+      getEvaluateText,
+      showCountdown,
+      showRange,
+      getTotalLen,
+      countdown,
+      clearTimer,
+      disabledEvaluate,
+      isBanStart
+    } = useEvaluate(props, state, { emit });
+    onMounted(() => {
+      init();
+    });
+    const init = () => {
+      getTotalLen();
+      handleEvaluateParams();
+    };
+    const handleEvaluateParams = () => {
+      if (!props.evaluateResultSetting || !Object.keys(props.evaluateResultSetting).length)
+        return;
+      if (showRange.value) {
+        let formatStart = moment(evaluateStartTime.value).format("YYYY\u5E74MM\u6708DD\u65E5HH:mm:ss");
+        if (getEvaluateTime.value) {
+          let rangTime = moment(evaluateStartTime.value).add(getEvaluateTime.value, "minutes");
+          let formatEnd = rangTime.format("YYYY\u5E74MM\u6708DD\u65E5HH:mm:ss");
+          state.timeRange = `${formatStart}~${formatEnd}`;
+        } else {
+          state.timeRange = `${formatStart}`;
+        }
+      }
+      if (!evaluateStartTime.value)
+        return;
+      let time = getEvaluateStartTime.value;
+      console.log(time, "--time");
+      if (!time)
+        return;
+      let startTime = time.getTime();
+      clearTimer();
+      countdown(startTime);
+    };
+    const writeGuage = () => {
+      console.log("\u89E6\u53D1---writeGuage");
+      clearTimer();
+      let banStart = isBanStart();
+      state.banStart = banStart;
+      if (state.banStart)
+        return;
+      emit("writeGuage", showCountdown.value);
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        createElementVNode("div", _hoisted_2, [
+          props.evaluateResultSetting.evaluateName ? (openBlock(), createElementBlock("h4", _hoisted_3, toDisplayString(props.evaluateResultSetting.evaluateName), 1)) : createCommentVNode("v-if", true),
+          props.evaluateResultSetting.evaluateExplain ? (openBlock(), createElementBlock("div", _hoisted_4, [
+            createElementVNode("div", null, toDisplayString(props.evaluateResultSetting.evaluateExplain), 1)
+          ])) : createCommentVNode("v-if", true),
+          createElementVNode("ul", _hoisted_5, [
+            createElementVNode("li", null, [
+              createElementVNode("div", null, toDisplayString(unref(evaluateState).totalLen), 1),
+              _hoisted_6
+            ]),
+            createElementVNode("li", null, [
+              createElementVNode("div", null, toDisplayString(props.maxScore), 1),
+              _hoisted_7
+            ]),
+            unref(getEvaluateTime) ? (openBlock(), createElementBlock("li", _hoisted_8, [
+              createElementVNode("div", null, toDisplayString(unref(getEvaluateTime)), 1),
+              _hoisted_9
+            ])) : createCommentVNode("v-if", true)
+          ]),
+          unref(showRange) ? (openBlock(), createElementBlock("div", _hoisted_10, toDisplayString(state.timeRange), 1)) : createCommentVNode("v-if", true),
+          createVNode(unref(NButton), {
+            class: "evaluate-btn",
+            type: "primary",
+            onClick: writeGuage,
+            disabled: unref(disabledEvaluate) || state.banStart
+          }, {
+            default: withCtx(() => [
+              createTextVNode(toDisplayString(unref(getEvaluateText)) + " ", 1),
+              !unref(evaluateState).isTimeOut && unref(evaluateState).countdownStr ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
+                createTextVNode(" \uFF08" + toDisplayString(unref(evaluateState).countdownStr) + "\uFF09 ", 1)
+              ], 64)) : createCommentVNode("v-if", true)
+            ]),
+            _: 1
+          }, 8, ["disabled"])
+        ])
+      ]);
+    };
+  }
+});
+var EvaluatePage = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "EvaluatePage.vue"]]);
+
+export { EvaluatePage as default };

package/es/components/scale-view/src/components/EvaluatePage.vue.d.ts

@@ -0,0 +1,110 @@
+declare const _default: import("vue").DefineComponent<{
+    formArray: {
+        type: ArrayConstructor;
+        default: () => never[];
+    };
+    evaluateResultConfig: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    evaluateResultSetting: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    isFinished: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    maxScore: {
+        type: NumberConstructor;
+        default: number;
+    };
+}, {
+    state: {
+        source: string;
+        timer: null;
+        curTime: number;
+        timeRange: string;
+        banStart: boolean;
+    };
+    props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+        formArray: {
+            type: ArrayConstructor;
+            default: () => never[];
+        };
+        evaluateResultConfig: {
+            type: ObjectConstructor;
+            default: () => {};
+        };
+        evaluateResultSetting: {
+            type: ObjectConstructor;
+            default: () => {};
+        };
+        isFinished: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        maxScore: {
+            type: NumberConstructor;
+            default: number;
+        };
+    }>> & {
+        onCloseEvaluateCountdown?: ((...args: any[]) => any) | undefined;
+        onWriteGuage?: ((...args: any[]) => any) | undefined;
+    }>>;
+    emit: (event: "closeEvaluateCountdown" | "writeGuage", ...args: any[]) => void;
+    evaluateState: {
+        totalLen: number;
+        timer: null;
+        countdownStr: string;
+        isTimeOut: boolean;
+        countdownRed: boolean;
+        filterArr: string[];
+    };
+    evaluateStartTime: any;
+    getEvaluateTime: any;
+    getEvaluateStartTime: import("vue").ComputedRef<false | Date>;
+    getEvaluateText: import("vue").ComputedRef<"测评已结束" | "开始测评">;
+    showCountdown: import("vue").ComputedRef<any>;
+    showRange: import("vue").ComputedRef<boolean>;
+    getTotalLen: () => void;
+    countdown: (startTime: any) => void;
+    clearTimer: () => void;
+    disabledEvaluate: import("vue").ComputedRef<any>;
+    isBanStart: () => boolean;
+    init: () => void;
+    handleEvaluateParams: () => void;
+    writeGuage: () => void;
+    NButton: any;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("closeEvaluateCountdown" | "writeGuage")[], "closeEvaluateCountdown" | "writeGuage", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    formArray: {
+        type: ArrayConstructor;
+        default: () => never[];
+    };
+    evaluateResultConfig: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    evaluateResultSetting: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    isFinished: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    maxScore: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & {
+    onCloseEvaluateCountdown?: ((...args: any[]) => any) | undefined;
+    onWriteGuage?: ((...args: any[]) => any) | undefined;
+}, {
+    formArray: unknown[];
+    evaluateResultConfig: Record<string, any>;
+    evaluateResultSetting: Record<string, any>;
+    isFinished: boolean;
+    maxScore: number;
+}>;
+export default _default;