tanxin-ui 0.2.0

package/lib/calendar/src/calendar.js

@@ -0,0 +1,337 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+var vue = require("vue");
+var type = require("../../utils/type.js");
+var useConfig = require("../../utils/hooks/useConfig.js");
+require("../../utils/components/icons/Checkmark.js");
+require("../../utils/components/icons/CheckmarkCircle.js");
+require("../../utils/components/icons/CheckmarkSharp.js");
+require("../../utils/components/icons/CheckmarkCircleOutline.js");
+require("../../utils/components/icons/AlertCircle.js");
+require("../../utils/components/icons/AlertCircleOutline.js");
+require("../../utils/components/icons/InformationCircle.js");
+require("../../utils/components/icons/InformationCircleOutline.js");
+require("../../utils/components/icons/CloseCircle.js");
+require("../../utils/components/icons/CloseCircleOutline.js");
+require("../../utils/components/icons/HelpCircleSharp.js");
+require("../../utils/components/icons/EyeOffOutline.js");
+require("../../utils/components/icons/EyeOutline.js");
+require("../../utils/components/icons/LoadingOutlined.js");
+require("../../utils/components/icons/Close.js");
+require("../../utils/components/icons/CloseOutline.js");
+require("../../utils/components/icons/ArrowsMaximize.js");
+require("../../utils/components/icons/ArrowsMinimize.js");
+require("../../utils/components/icons/AddOutline.js");
+require("../../utils/components/icons/RemoveOutline.js");
+require("../../utils/components/icons/ChevronUp.js");
+require("../../utils/components/icons/ChevronDown.js");
+require("../../utils/components/icons/ChevronForward.js");
+require("../../utils/components/icons/ChevronLeft24Filled.js");
+require("../../utils/components/icons/ChevronRight24Filled.js");
+require("../../utils/components/icons/ChevronDoubleLeft16Filled.js");
+require("../../utils/components/icons/ChevronDoubleRight16Filled.js");
+require("../../utils/components/icons/CheckmarkOutline.js");
+require("../../utils/components/icons/IosCheckmark.js");
+require("../../utils/components/icons/Empty.js");
+require("../../utils/components/icons/Bars.js");
+require("../../utils/components/icons/ArrowUpCircle.js");
+require("../../utils/components/icons/ArrowUp.js");
+require("../../utils/components/icons/ArrowForward.js");
+require("../../utils/components/icons/TimeOutline.js");
+require("../../utils/components/icons/CalendarClearOutline.js");
+var KeyboardArrowLeftRound = require("../../utils/components/icons/KeyboardArrowLeftRound.js");
+var KeyboardArrowRightRound = require("../../utils/components/icons/KeyboardArrowRightRound.js");
+var KeyboardDoubleArrowLeftRound = require("../../utils/components/icons/KeyboardDoubleArrowLeftRound.js");
+var KeyboardDoubleArrowRightRound = require("../../utils/components/icons/KeyboardDoubleArrowRightRound.js");
+require("../../utils/components/icons/MenuFoldOutlined.js");
+require("../../utils/components/icons/IosArrowDown.js");
+require("../../utils/components/icons/IosArrowBack.js");
+require("../../utils/components/icons/IosArrowForward.js");
+require("../../utils/components/icons/ImageSharp.js");
+require("../../utils/components/icons/Pause.js");
+require("../../utils/components/icons/Refresh.js");
+require("../../utils/components/icons/QuestionCircle24Regular.js");
+require("../../utils/components/icons/CloudUploadOutline.js");
+require("../../utils/components/icons/UploadFileFilled.js");
+require("../../utils/components/icons/EllipsisHorizontal.js");
+require("../../utils/components/icons/ArrowNext24Filled.js");
+require("../../utils/components/icons/ArrowPrevious24Filled.js");
+require("../../utils/components/icons/ArrowDropDownSharp.js");
+require("../../utils/components/icons/ArrowDropUpSharp.js");
+require("../../utils/components/icons/ArrowForwardIosFilled.js");
+var dayjs = require("dayjs");
+var index = require("../../popper/index.js");
+var common = require("../../utils/common.js");
+var weekOfYear = require("dayjs/plugin/weekOfYear");
+var advancedFormat = require("dayjs/plugin/advancedFormat");
+function _interopDefaultLegacy(e) {
+  return e && typeof e === "object" && "default" in e ? e : { "default": e };
+}
+var dayjs__default = /* @__PURE__ */ _interopDefaultLegacy(dayjs);
+var weekOfYear__default = /* @__PURE__ */ _interopDefaultLegacy(weekOfYear);
+var advancedFormat__default = /* @__PURE__ */ _interopDefaultLegacy(advancedFormat);
+dayjs__default["default"].extend(advancedFormat__default["default"]);
+dayjs__default["default"].extend(weekOfYear__default["default"]);
+const calendarProps = {
+  week: type.PropTypes.bool.def(true),
+  showHeader: type.PropTypes.bool.def(true),
+  value: {
+    type: Array,
+    default: () => []
+  },
+  panelDate: {
+    type: [String, Object]
+  },
+  data: type.PropTypes.array.def([]),
+  dateKey: type.PropTypes.string.def("date"),
+  multiple: type.PropTypes.bool.def(false),
+  dayClass: type.PropTypes.string,
+  disabledDates: {
+    type: Function
+  },
+  cellMinHeight: [String, Number],
+  cellMaxHeight: [String, Number]
+};
+var Calendar = vue.defineComponent({
+  name: "TCalendar",
+  components: {
+    TPopper: index.TPopper,
+    KeyboardArrowLeftRound: KeyboardArrowLeftRound["default"],
+    KeyboardArrowRightRound: KeyboardArrowRightRound["default"],
+    KeyboardDoubleArrowLeftRound: KeyboardDoubleArrowLeftRound["default"],
+    KeyboardDoubleArrowRightRound: KeyboardDoubleArrowRightRound["default"]
+  },
+  inheritAttrs: false,
+  props: calendarProps,
+  emits: ["change", "update:value", "panelDateChange"],
+  setup(props, {
+    slots,
+    emit,
+    attrs
+  }) {
+    const {
+      prefixCls
+    } = useConfig.useConfig("calendar", props);
+    const format = "YYYY-MM-DD";
+    const selectedDays = vue.ref(props.value);
+    const panelDate = vue.ref();
+    const styles = vue.computed(() => {
+      const style = {};
+      if (props.cellMinHeight) {
+        style[`--t-calendar-cell-min-height`] = common.getLength(props.cellMinHeight);
+      }
+      if (props.cellMaxHeight) {
+        style[`--t-calendar-cell-max-height`] = common.getLength(props.cellMaxHeight);
+      }
+      return style;
+    });
+    const toPrevMonth = () => {
+      panelDate.value = panelDate.value.subtract(1, "month");
+      panelDataChange();
+    };
+    const toNextMonth = () => {
+      panelDate.value = panelDate.value.add(1, "month");
+      panelDataChange();
+    };
+    const toPrevYear = () => {
+      panelDate.value = panelDate.value.subtract(1, "year");
+      panelDataChange();
+    };
+    const toNextYear = () => {
+      panelDate.value = panelDate.value.add(1, "year");
+      panelDataChange();
+    };
+    const toThisMonth = () => {
+      panelDate.value = dayjs__default["default"]().startOf("month");
+      panelDataChange();
+    };
+    const setPanelDate = (value) => {
+      panelDate.value = value.startOf("month");
+      panelDataChange();
+    };
+    const panelDataChange = () => {
+      emit("panelDateChange", {
+        panelDate: panelDate.value.format(format),
+        beginDate: panelDate.value.subtract(beforeDays.value, "day").format(format),
+        endDate: panelDate.value.endOf("month").add(afterDays.value, "day").format(format)
+      });
+    };
+    const initPanelDate = () => {
+      if (props.panelDate) {
+        if (type.isString(props.panelDate))
+          panelDate.value = dayjs__default["default"](props.panelDate);
+      } else if (props.value) {
+        panelDate.value = dayjs__default["default"](props.value[0]).startOf("month");
+      } else
+        panelDate.value = dayjs__default["default"]().startOf("month");
+      panelDataChange();
+    };
+    vue.onBeforeMount(() => {
+      initPanelDate();
+    });
+    vue.watch(() => props.value, () => {
+      selectedDays.value = props.value;
+      initPanelDate();
+    });
+    vue.watch(() => props.panelDate, () => {
+      initPanelDate();
+    });
+    const beforeDays = vue.computed(() => {
+      return panelDate.value.day() > 0 ? panelDate.value.day() - 1 : 6;
+    });
+    const afterDays = vue.computed(() => {
+      const allDays = 42;
+      return allDays - beforeDaysElement.value.length - currentDaysElement.value.length;
+    });
+    const handleDayClick = (value) => {
+      const day = value.format("YYYY-MM-DD");
+      const index2 = selectedDays.value.indexOf(day);
+      if (props.multiple) {
+        if (index2 >= 0)
+          selectedDays.value.splice(index2, 1);
+        else
+          selectedDays.value.push(day);
+      } else {
+        if (index2 >= 0)
+          selectedDays.value = [];
+        else
+          selectedDays.value = [day];
+      }
+      setPanelDate(value);
+      emit("change", selectedDays.value);
+    };
+    const weekElement = vue.computed(() => {
+      const value = ["\u4E00", "\u4E8C", "\u4E09", "\u56DB", "\u4E94", "\u516D", "\u65E5"].map((item) => {
+        return vue.createVNode("div", {
+          "class": `${prefixCls.value}-th`
+        }, [vue.createVNode("span", {
+          "class": `${prefixCls.value}-words`
+        }, [item])]);
+      });
+      return value;
+    });
+    const isDisabled = (day) => {
+      return props.disabledDates ? props.disabledDates(day) : false;
+    };
+    const getDayData = (day) => {
+      return props.data.find((item) => {
+        var _a;
+        let date = (_a = item[props.dateKey]) != null ? _a : "1001-01-01";
+        if (type.isString(date))
+          date = dayjs__default["default"](date);
+        return common.isSameDate(date, day, format);
+      });
+    };
+    const oneDayElement = (day, isOther) => {
+      var _a;
+      let dayClasses = [];
+      const disabled = isDisabled(day);
+      if (isOther) {
+        dayClasses = [[`${prefixCls.value}-td`], {
+          [`is-other`]: isOther,
+          [`is-disabled`]: disabled
+        }];
+      } else {
+        const isSelected = selectedDays.value.includes(day.format("YYYY-MM-DD"));
+        dayClasses = [[`${prefixCls.value}-td`], {
+          [`is-other`]: isOther,
+          [`is-today`]: common.isSameDate(day, dayjs__default["default"]()),
+          [`is-selected`]: isSelected,
+          [`is-disabled`]: disabled
+        }];
+      }
+      const dayProps = disabled ? null : {
+        onClick: () => {
+          handleDayClick(day);
+        }
+      };
+      return vue.createVNode(vue.Fragment, null, [vue.createVNode("div", vue.mergeProps({
+        "class": dayClasses
+      }, dayProps), [vue.createVNode("div", {
+        "class": [[`${prefixCls.value}-td-sys`], {
+          [`${props.dayClass}`]: props.dayClass,
+          [`is-other`]: isOther
+        }]
+      }, [vue.createVNode("span", null, [day.date()]), vue.createVNode("div", {
+        "class": "selected-angle"
+      }, null)]), (_a = slots.render) == null ? void 0 : _a.call(slots, getDayData(day))])]);
+    };
+    const beforeDaysElement = vue.computed(() => {
+      const days = beforeDays.value;
+      return [...Array(days)].map((item, index2) => {
+        const day = panelDate.value.subtract(days - index2, "day");
+        return oneDayElement(day, true);
+      });
+    });
+    const currentDaysElement = vue.computed(() => {
+      return [...Array(panelDate.value.daysInMonth())].map((item, index2) => {
+        const day = panelDate.value.add(index2, "day");
+        return oneDayElement(day, false);
+      });
+    });
+    const afterDaysElement = vue.computed(() => {
+      const days = afterDays.value;
+      return [...Array(days)].map((item, index2) => {
+        const day = panelDate.value.add(1, "month").add(index2, "day");
+        return oneDayElement(day, true);
+      });
+    });
+    const render = () => {
+      var _a;
+      const bodyElement = vue.createVNode(vue.Fragment, null, [beforeDaysElement.value, currentDaysElement.value, afterDaysElement.value]);
+      const headerElement = vue.createVNode(vue.Fragment, null, [vue.createVNode("div", {
+        "class": `${prefixCls.value}-header-left`
+      }, [vue.createTextVNode(" "), panelDate.value.format("YYYY\u5E74 MM\u6708")]), vue.createVNode("div", {
+        "class": `${prefixCls.value}-header-right`
+      }, [vue.createVNode(vue.resolveComponent("t-space"), {
+        "button-group": true,
+        "size": -1
+      }, {
+        default: () => [vue.createVNode(vue.resolveComponent("t-button"), {
+          "type": "default",
+          "onClick": toPrevYear
+        }, {
+          default: () => ["<<"]
+        }), vue.createVNode(vue.resolveComponent("t-button"), {
+          "type": "default",
+          "onClick": toPrevMonth
+        }, {
+          default: () => ["<"]
+        }), vue.createVNode(vue.resolveComponent("t-button"), {
+          "type": "default",
+          "onClick": toThisMonth
+        }, {
+          default: () => [vue.createTextVNode("\u672C\u6708")]
+        }), vue.createVNode(vue.resolveComponent("t-button"), {
+          "type": "default",
+          "onClick": toNextMonth
+        }, {
+          default: () => [">"]
+        }), vue.createVNode(vue.resolveComponent("t-button"), {
+          "type": "default",
+          "onClick": toNextYear
+        }, {
+          default: () => [">>"]
+        })]
+      })])]);
+      return vue.createVNode(vue.Fragment, null, [vue.createVNode("div", vue.mergeProps({
+        "class": `${prefixCls.value}`
+      }, attrs, {
+        "style": styles.value
+      }), [props.showHeader ? vue.createVNode("div", {
+        "class": `${prefixCls.value}-header`
+      }, [slots.header ? (_a = slots.header) == null ? void 0 : _a.call(slots) : headerElement]) : null, props.week ? vue.createVNode("div", {
+        "class": `${prefixCls.value}-week`
+      }, [vue.createTextVNode(" "), weekElement.value]) : null, vue.createVNode("div", {
+        "class": `${prefixCls.value}-body`
+      }, [bodyElement])])]);
+    };
+    return {
+      render
+    };
+  },
+  render() {
+    return this.render();
+  }
+});
+exports["default"] = Calendar;

package/lib/card/index.d.ts

@@ -0,0 +1,206 @@
+declare const TCard: {
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            title: string;
+            showHeader: boolean;
+            shadow: string;
+            showBorder: boolean;
+            showSplit: boolean;
+            clean: boolean;
+            borderDashed: boolean;
+        }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+            title: import("vue-types").VueTypeValidableDef<string> & {
+                default: string;
+            };
+            icon: import("vue").PropType<import("../utils/type").VueNode | (() => import("../utils/type").VueNode)>;
+            shadow: import("vue-types").VueTypeDef<string> & {
+                default: string;
+            };
+            showHeader: import("vue-types").VueTypeValidableDef<boolean> & {
+                default: boolean;
+            } & {
+                default: boolean;
+            };
+            showBorder: import("vue-types").VueTypeValidableDef<boolean> & {
+                default: boolean;
+            } & {
+                default: boolean;
+            };
+            showSplit: import("vue-types").VueTypeValidableDef<boolean> & {
+                default: boolean;
+            } & {
+                default: boolean;
+            };
+            clean: import("vue-types").VueTypeValidableDef<boolean> & {
+                default: boolean;
+            } & {
+                default: boolean;
+            };
+            borderDashed: import("vue-types").VueTypeValidableDef<boolean> & {
+                default: boolean;
+            } & {
+                default: boolean;
+            };
+        }>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "title" | "showHeader" | "shadow" | "showBorder" | "showSplit" | "clean" | "borderDashed">;
+        $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: string, ...args: any[]) => void;
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+            title: import("vue-types").VueTypeValidableDef<string> & {
+                default: string;
+            };
+            icon: import("vue").PropType<import("../utils/type").VueNode | (() => import("../utils/type").VueNode)>;
+            shadow: import("vue-types").VueTypeDef<string> & {
+                default: string;
+            };
+            showHeader: import("vue-types").VueTypeValidableDef<boolean> & {
+                default: boolean;
+            } & {
+                default: boolean;
+            };
+            showBorder: import("vue-types").VueTypeValidableDef<boolean> & {
+                default: boolean;
+            } & {
+                default: boolean;
+            };
+            showSplit: import("vue-types").VueTypeValidableDef<boolean> & {
+                default: boolean;
+            } & {
+                default: boolean;
+            };
+            clean: import("vue-types").VueTypeValidableDef<boolean> & {
+                default: boolean;
+            } & {
+                default: boolean;
+            };
+            borderDashed: import("vue-types").VueTypeValidableDef<boolean> & {
+                default: boolean;
+            } & {
+                default: boolean;
+            };
+        }>>, {
+            render: () => JSX.Element;
+        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, {
+            title: string;
+            showHeader: boolean;
+            shadow: string;
+            showBorder: boolean;
+            showSplit: boolean;
+            clean: boolean;
+            borderDashed: 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<{
+        title: import("vue-types").VueTypeValidableDef<string> & {
+            default: string;
+        };
+        icon: import("vue").PropType<import("../utils/type").VueNode | (() => import("../utils/type").VueNode)>;
+        shadow: import("vue-types").VueTypeDef<string> & {
+            default: string;
+        };
+        showHeader: import("vue-types").VueTypeValidableDef<boolean> & {
+            default: boolean;
+        } & {
+            default: boolean;
+        };
+        showBorder: import("vue-types").VueTypeValidableDef<boolean> & {
+            default: boolean;
+        } & {
+            default: boolean;
+        };
+        showSplit: import("vue-types").VueTypeValidableDef<boolean> & {
+            default: boolean;
+        } & {
+            default: boolean;
+        };
+        clean: import("vue-types").VueTypeValidableDef<boolean> & {
+            default: boolean;
+        } & {
+            default: boolean;
+        };
+        borderDashed: import("vue-types").VueTypeValidableDef<boolean> & {
+            default: boolean;
+        } & {
+            default: boolean;
+        };
+    }>> & import("vue").ShallowUnwrapRef<{
+        render: () => JSX.Element;
+    }> & {} & import("vue").ComponentCustomProperties;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    title: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+    icon: import("vue").PropType<import("../utils/type").VueNode | (() => import("../utils/type").VueNode)>;
+    shadow: import("vue-types").VueTypeDef<string> & {
+        default: string;
+    };
+    showHeader: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    showBorder: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    showSplit: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    clean: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    borderDashed: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+}>>, {
+    render: () => JSX.Element;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, {
+    title: string;
+    showHeader: boolean;
+    shadow: string;
+    showBorder: boolean;
+    showSplit: boolean;
+    clean: boolean;
+    borderDashed: boolean;
+}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("@vue/runtime-core").Plugin;
+export { TCard };

package/lib/card/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+var type = require("../utils/type.js");
+var card = require("./src/card.js");
+const TCard = type.withInstall(card["default"]);
+exports.TCard = TCard;

package/lib/card/src/card.d.ts

@@ -0,0 +1,78 @@
+declare const _default: import("vue").DefineComponent<{
+    title: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+    icon: import("vue").PropType<import("../../utils/type").VueNode | (() => import("../../utils/type").VueNode)>;
+    shadow: import("vue-types").VueTypeDef<string> & {
+        default: string;
+    };
+    showHeader: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    showBorder: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    showSplit: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    clean: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    borderDashed: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+}, {
+    render: () => JSX.Element;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    title: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+    icon: import("vue").PropType<import("../../utils/type").VueNode | (() => import("../../utils/type").VueNode)>;
+    shadow: import("vue-types").VueTypeDef<string> & {
+        default: string;
+    };
+    showHeader: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    showBorder: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    showSplit: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    clean: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    borderDashed: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+}>>, {
+    title: string;
+    showHeader: boolean;
+    shadow: string;
+    showBorder: boolean;
+    showSplit: boolean;
+    clean: boolean;
+    borderDashed: boolean;
+}>;
+export default _default;