tanxin-ui 0.2.0

package/lib/modal/src/modal.js

@@ -0,0 +1,458 @@
+"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");
+var index = require("../../icon/index.js");
+var index$1 = require("../../button/index.js");
+var scrollbarWidth = require("../../utils/scrollbarWidth.js");
+require("../../utils/components/icons/Checkmark.js");
+var CheckmarkCircle = require("../../utils/components/icons/CheckmarkCircle.js");
+require("../../utils/components/icons/CheckmarkSharp.js");
+require("../../utils/components/icons/CheckmarkCircleOutline.js");
+var AlertCircle = require("../../utils/components/icons/AlertCircle.js");
+require("../../utils/components/icons/AlertCircleOutline.js");
+var InformationCircle = require("../../utils/components/icons/InformationCircle.js");
+require("../../utils/components/icons/InformationCircleOutline.js");
+var CloseCircle = 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");
+var LoadingOutlined = require("../../utils/components/icons/LoadingOutlined.js");
+require("../../utils/components/icons/Close.js");
+var CloseOutline = require("../../utils/components/icons/CloseOutline.js");
+var ArrowsMaximize = require("../../utils/components/icons/ArrowsMaximize.js");
+var ArrowsMinimize = 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");
+require("../../utils/components/icons/KeyboardArrowLeftRound.js");
+require("../../utils/components/icons/KeyboardArrowRightRound.js");
+require("../../utils/components/icons/KeyboardDoubleArrowLeftRound.js");
+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 transition = require("../../utils/transition.js");
+var common = require("../../utils/common.js");
+function _isSlot(s) {
+  return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !vue.isVNode(s);
+}
+const messageItemProps = {
+  visible: type.PropTypes.bool.def(false),
+  resizable: type.PropTypes.bool.def(false),
+  fullscreen: type.PropTypes.bool.def(false),
+  center: type.PropTypes.bool.def(false),
+  loading: type.PropTypes.bool.def(false),
+  width: type.PropTypes.oneOfType([type.PropTypes.string, type.PropTypes.number]).def(520),
+  height: type.PropTypes.oneOfType([type.PropTypes.string, type.PropTypes.number]),
+  closable: type.PropTypes.bool.def(true),
+  closeText: type.PropTypes.string,
+  title: type.PropTypes.string,
+  showMask: type.PropTypes.bool.def(true),
+  maskClosable: type.PropTypes.bool.def(true),
+  esc: type.PropTypes.bool.def(true),
+  cancelable: type.PropTypes.bool.def(true),
+  showFooter: type.PropTypes.bool.def(true),
+  bodyPadding: type.PropTypes.string,
+  cancelText: type.PropTypes.string.def("\u5173\u95ED"),
+  cancelType: type.PropTypes.oneOf(["primary", "success", "warning", "danger", "info", "default"]).def("default"),
+  cancelProps: {
+    type: Object,
+    default: () => ({})
+  },
+  okText: type.PropTypes.string.def("\u786E\u5B9A"),
+  okType: type.PropTypes.oneOf(["primary", "success", "warning", "danger", "info", "default"]).def("primary"),
+  okProps: {
+    type: Object,
+    default: () => ({})
+  },
+  draggable: type.PropTypes.bool.def(false),
+  sticky: type.PropTypes.bool.def(true),
+  stickyDistance: type.PropTypes.oneOfType([type.PropTypes.string, type.PropTypes.number]).def(10),
+  resetPosition: type.PropTypes.bool.def(false)
+};
+let clickPosition = {
+  x: 0,
+  y: 0
+};
+var Modal = vue.defineComponent({
+  name: "TModal",
+  components: {
+    TIcon: index.TIcon,
+    CheckmarkCircle: CheckmarkCircle["default"],
+    AlertCircle: AlertCircle["default"],
+    InformationCircle: InformationCircle["default"],
+    CloseCircle: CloseCircle["default"],
+    LoadingOutlined: LoadingOutlined["default"],
+    ArrowsMaximize: ArrowsMaximize["default"],
+    ArrowsMinimize: ArrowsMinimize["default"],
+    CloseOutline: CloseOutline["default"],
+    TButton: index$1.TButton
+  },
+  inheritAttrs: false,
+  props: messageItemProps,
+  emits: ["update:visible", "ok"],
+  setup(props, {
+    slots,
+    emit,
+    attrs
+  }) {
+    const {
+      prefixCls
+    } = useConfig.useConfig("modal", props);
+    const visible = vue.ref(props.visible);
+    const refDialog = vue.ref();
+    const refHeader = vue.ref();
+    const fullscreen = vue.ref(props.fullscreen);
+    const classes = vue.computed(() => {
+      return [[`${prefixCls.value}-container`], {
+        [`is-fullscreen`]: fullscreen.value,
+        [`is-center`]: props.center,
+        [`is-draggable`]: props.draggable && !fullscreen.value
+      }];
+    });
+    const styles = vue.computed(() => {
+      const style = {};
+      if (props.width && !fullscreen.value) {
+        style[`width`] = common.getLength(props.width);
+        dialogPosition.value ? style[`max-width`] = "94%" : null;
+      }
+      if (props.height && !fullscreen.value) {
+        style[`height`] = common.getLength(props.height);
+      }
+      if (dialogPosition.value) {
+        style["left"] = `${dialogPosition.value.x}px`;
+        style["top"] = `${dialogPosition.value.y}px`;
+      }
+      return style;
+    });
+    const containerStyles = vue.computed(() => {
+      const style = {};
+      if (props.width && !fullscreen.value) {
+        style[`width`] = dialogPosition.value ? "100%" : common.getLength(props.width);
+        style[`max-width`] = dialogPosition.value ? "100%" : "94%";
+      }
+      return style;
+    });
+    const bodyStyles = vue.computed(() => {
+      const style = {};
+      if (props.bodyPadding) {
+        style[`--t-modal-body-padding`] = props.bodyPadding;
+      }
+      return style;
+    });
+    const maskClasses = vue.computed(() => {
+      return [[`${prefixCls.value}-mask`], {
+        [`${prefixCls.value}-mask-disabled`]: !props.maskClosable
+      }];
+    });
+    vue.watch(() => props.visible, () => {
+      visible.value = props.visible;
+    });
+    vue.watch(() => props.loading, () => {
+      loading.value = props.loading;
+    });
+    vue.watch(() => visible.value, () => {
+      if (!common.isClient)
+        return;
+      if (visible.value) {
+        vue.nextTick(() => {
+          setTransformOrigin();
+        });
+        if (props.resetPosition)
+          dialogPosition.value = null;
+      } else
+        loading.value = false;
+      const hasScroll = scrollbarWidth.originHasScroll(document.body);
+      if (visible.value)
+        scrollbarWidth.handleAboutScrollbar(document.body, hasScroll, false);
+      else
+        scrollbarWidth.handleAboutScrollbar(document.body, hasScroll, hasScroll);
+    });
+    const setTransformOrigin = () => {
+      if (!common.isClient)
+        return;
+      const scrollLeft = document.body.scrollLeft || document.documentElement.scrollLeft;
+      const scrollTop = document.body.scrollTop || document.documentElement.scrollTop;
+      const rect = refDialog.value.getBoundingClientRect();
+      const pos = {
+        left: rect.left + scrollLeft,
+        top: rect.top + scrollTop
+      };
+      const value = `${clickPosition.x - pos.left}px ${clickPosition.y - pos.top}px`;
+      const style = refDialog.value.style;
+      ["Webkit", "Moz", "Ms", "ms"].forEach((prefix) => {
+        style[`${prefix}TransformOrigin`] = value;
+      });
+      style[`transformOrigin`] = value;
+    };
+    const updateMousePosition = (event) => {
+      clickPosition = {
+        x: event.pageX,
+        y: event.pageY
+      };
+    };
+    const handleClose = () => {
+      visible.value = false;
+      emit("update:visible", false);
+    };
+    const handleKeyup = (event) => {
+      if (event.code == "Escape")
+        handleClose();
+    };
+    const mouseMoving = vue.ref(false);
+    const dialogPosition = vue.ref();
+    let mousePosition;
+    const handleMousedown = (event) => {
+      if (!common.isClient)
+        return;
+      if (!props.draggable || fullscreen.value)
+        return;
+      mouseMoving.value = true;
+      const rect = refDialog.value.getBoundingClientRect();
+      dialogPosition.value = {
+        x: rect.x,
+        y: rect.y,
+        width: rect.width,
+        height: rect.height
+      };
+      let e = event;
+      if (e.type == "touchstart")
+        e = event.touches[0];
+      mousePosition = {
+        x: e.clientX,
+        y: e.clientY
+      };
+      document.onselectstart = () => false;
+      document.addEventListener("mousemove", handleMousemove, true);
+      document.addEventListener("mouseup", handleMouseup, true);
+      document.addEventListener("touchmove", handleMousemove, true);
+      document.addEventListener("touchend", handleMouseup, true);
+    };
+    const stickyDistance = common.getLengthNumber(props.stickyDistance);
+    const handleMousemove = (event) => {
+      if (!common.isClient)
+        return;
+      if (!mouseMoving.value)
+        return;
+      let e = event;
+      if (e.type == "touchmove")
+        e = event.touches[0];
+      const diffX = e.clientX - mousePosition.x;
+      const diffY = e.clientY - mousePosition.y;
+      dialogPosition.value.x = dialogPosition.value.x + diffX;
+      dialogPosition.value.y = dialogPosition.value.y + diffY;
+      if (props.sticky) {
+        const clientWidth = document.documentElement.clientWidth;
+        const clientHeight = document.documentElement.clientHeight;
+        const dialogNext = {
+          x: dialogPosition.value.x + diffX,
+          y: dialogPosition.value.y + diffY
+        };
+        if (diffX < 0) {
+          if (dialogNext.x - 0 < stickyDistance) {
+            dialogPosition.value.x = 0;
+          }
+        } else if (diffX > 0) {
+          if (clientWidth - (dialogNext.x + dialogPosition.value.width) < stickyDistance) {
+            dialogPosition.value.x = clientWidth - dialogPosition.value.width;
+          }
+        }
+        if (diffY < 0) {
+          if (dialogNext.y - 0 < stickyDistance) {
+            dialogPosition.value.y = 0;
+          }
+        } else if (diffY > 0) {
+          if (clientHeight - (dialogNext.y + dialogPosition.value.height) < stickyDistance) {
+            dialogPosition.value.y = clientHeight - dialogPosition.value.height;
+          }
+        }
+      }
+      mousePosition = {
+        x: e.clientX,
+        y: e.clientY
+      };
+    };
+    const handleMouseup = () => {
+      if (!common.isClient)
+        return;
+      document.onselectstart = null;
+      mouseMoving.value = false;
+      document.removeEventListener("mousemove", handleMousemove, true);
+      document.removeEventListener("mouseup", handleMouseup, true);
+      document.removeEventListener("touchmove", handleMousemove, true);
+      document.removeEventListener("touchend", handleMouseup, true);
+    };
+    vue.onMounted(() => {
+      if (!common.isClient)
+        return;
+      props.esc ? document.addEventListener("keyup", handleKeyup, true) : null;
+      document.addEventListener("click", updateMousePosition, true);
+      refHeader.value.addEventListener("mousedown", handleMousedown, true);
+      refHeader.value.addEventListener("touchstart", handleMousedown, {
+        capture: true,
+        passive: true
+      });
+    });
+    vue.onBeforeUnmount(() => {
+      if (!common.isClient)
+        return;
+      props.esc ? document.removeEventListener("keyup", handleKeyup, true) : null;
+      document.removeEventListener("click", updateMousePosition, true);
+      refHeader.value.removeEventListener("mousedown", handleMousedown, true);
+      refHeader.value.removeEventListener("touchstart", handleMousedown, {
+        capture: true
+      });
+    });
+    const loading = vue.ref(false);
+    const handleOk = () => {
+      if (props.loading) {
+        loading.value = true;
+      }
+      emit("ok");
+    };
+    let dialogPositionOld;
+    const handleFullscreen = () => {
+      if (!props.resizable)
+        return;
+      fullscreen.value = !fullscreen.value;
+      if (dialogPosition.value) {
+        if (fullscreen.value) {
+          dialogPositionOld = {
+            x: dialogPosition.value.x,
+            y: dialogPosition.value.y
+          };
+          dialogPosition.value.x = 0;
+          dialogPosition.value.y = 0;
+        } else if (dialogPositionOld) {
+          dialogPosition.value.x = dialogPositionOld.x;
+          dialogPosition.value.y = dialogPositionOld.y;
+        }
+      }
+    };
+    const render = () => {
+      const maskTransitionProps = transition.getTransitionGroupProps("fade");
+      const transitionProps = transition.getTransitionGroupProps("zoom");
+      const maskElement = props.showMask ? vue.createVNode(vue.Transition, maskTransitionProps, {
+        default: () => [vue.withDirectives(vue.createVNode("div", {
+          "class": maskClasses.value,
+          "onClick": props.maskClosable ? handleClose : null
+        }, null), [[vue.vShow, visible.value]])]
+      }) : null;
+      const cancelElement = slots.cancelText ? slots.cancelText() : props.cancelText;
+      const closeElement = slots.closeText ? slots.closeText() : props.closeText ? props.closeText : vue.createVNode(vue.resolveComponent("t-icon"), null, {
+        default: () => [vue.createVNode(CloseOutline["default"], null, null)]
+      });
+      const okElement = slots.okText ? slots.okText() : props.okText;
+      const titleElement = slots.title ? slots.title() : props.title;
+      const fullscreenElement = vue.computed(() => {
+        return vue.createVNode(vue.resolveComponent("t-icon"), {
+          "class": "fullscreen-icon"
+        }, {
+          default: () => [fullscreen.value ? vue.createVNode(ArrowsMinimize["default"], null, null) : vue.createVNode(ArrowsMaximize["default"], null, null)]
+        });
+      });
+      const footerElement = slots.footer ? slots.footer() : vue.createVNode(vue.Fragment, null, [props.cancelable ? vue.createVNode(vue.resolveComponent("t-button"), vue.mergeProps({
+        "type": props.cancelType
+      }, props.cancelProps, {
+        "onClick": handleClose
+      }), _isSlot(cancelElement) ? cancelElement : {
+        default: () => [cancelElement]
+      }) : null, vue.createVNode(vue.resolveComponent("t-button"), vue.mergeProps({
+        "type": props.okType
+      }, props.okProps, {
+        "loading": loading.value,
+        "onClick": handleOk
+      }), _isSlot(okElement) ? okElement : {
+        default: () => [okElement]
+      })]);
+      return vue.createVNode(vue.Teleport, {
+        "to": "body"
+      }, {
+        default: () => [vue.createVNode("div", {
+          "class": `${prefixCls.value}`
+        }, [maskElement, vue.createVNode("div", {
+          "class": classes.value,
+          "style": containerStyles.value
+        }, [vue.createVNode(vue.Transition, transitionProps, {
+          default: () => {
+            var _a;
+            return [vue.withDirectives(vue.createVNode("div", vue.mergeProps({
+              "class": `${prefixCls.value}-dialog`,
+              "style": styles.value
+            }, attrs, {
+              "ref": refDialog,
+              "aria-modal": "true",
+              "role": "dialog"
+            }), [vue.createVNode("div", {
+              "class": `${prefixCls.value}-content`
+            }, [vue.createVNode("div", {
+              "ref": refHeader,
+              "class": `${prefixCls.value}-content-header`,
+              "onDblclick": handleFullscreen
+            }, [vue.createVNode("div", {
+              "class": `${prefixCls.value}-title`
+            }, [titleElement]), vue.createVNode("div", {
+              "class": `${prefixCls.value}-content-header-buttons`
+            }, [props.resizable ? vue.createVNode(vue.resolveComponent("t-button"), {
+              "class": `${prefixCls.value}-button`,
+              "show-wave": false,
+              "onClick": handleFullscreen
+            }, {
+              default: () => [fullscreenElement.value]
+            }) : null, props.closable ? vue.createVNode(vue.resolveComponent("t-button"), {
+              "class": `${prefixCls.value}-button`,
+              "show-wave": false,
+              "onClick": handleClose
+            }, _isSlot(closeElement) ? closeElement : {
+              default: () => [closeElement]
+            }) : null])]), vue.createVNode("div", {
+              "class": `${prefixCls.value}-content-body`,
+              "style": bodyStyles.value
+            }, [(_a = slots.default) == null ? void 0 : _a.call(slots)]), props.showFooter ? vue.createVNode("div", {
+              "class": `${prefixCls.value}-content-footer`
+            }, [footerElement]) : null])]), [[vue.vShow, visible.value]])];
+          }
+        })])])]
+      });
+    };
+    return {
+      render
+    };
+  },
+  render() {
+    return this.render();
+  }
+});
+exports["default"] = Modal;
+exports.messageItemProps = messageItemProps;

package/lib/notification/index.d.ts

@@ -0,0 +1,11 @@
+declare const TNotification: {
+    (): void;
+    success(options: import("./src/notification").NotificationItemParams, duration?: number): any;
+    info(options: import("./src/notification").NotificationItemParams, duration?: number): any;
+    warning(options: import("./src/notification").NotificationItemParams, duration?: number): any;
+    danger(options: import("./src/notification").NotificationItemParams, duration?: number): any;
+    config(options: Partial<Partial<import("./src/notification").NotificationListProps>>): void;
+    clear(): void;
+    close(messageId: string): any;
+} & import("@vue/runtime-core").Plugin;
+export { TNotification };

package/lib/notification/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 notification = require("./src/notification.js");
+const TNotification = type.withInstallFunction(notification["default"], "$notification");
+exports.TNotification = TNotification;

package/lib/notification/src/notification-item.d.ts

@@ -0,0 +1,150 @@
+import type { PropType } from 'vue';
+export declare type NotificationItemType = 'success' | 'info' | 'warning' | 'danger';
+export declare const notificationItemProps: {
+    type: {
+        type: PropType<NotificationItemType>;
+        default: string;
+    };
+    placement: import("vue-types").VueTypeDef<string> & {
+        default: string;
+    };
+    closable: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    duration: import("vue-types").VueTypeValidableDef<number> & {
+        default: number;
+    } & {
+        default: number;
+    };
+    showIcon: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    title: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+    content: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+    closeText: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+    messageId: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+    colorful: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    onClose: import("vue-types").VueTypeValidableDef<(...args: any[]) => any> & {
+        default: (...args: any[]) => any;
+    };
+};
+declare const _default: import("vue").DefineComponent<{
+    type: {
+        type: PropType<NotificationItemType>;
+        default: string;
+    };
+    placement: import("vue-types").VueTypeDef<string> & {
+        default: string;
+    };
+    closable: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    duration: import("vue-types").VueTypeValidableDef<number> & {
+        default: number;
+    } & {
+        default: number;
+    };
+    showIcon: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    title: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+    content: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+    closeText: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+    messageId: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+    colorful: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    onClose: import("vue-types").VueTypeValidableDef<(...args: any[]) => any> & {
+        default: (...args: any[]) => any;
+    };
+}, {
+    render: () => JSX.Element;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "afterClose"[], "afterClose", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    type: {
+        type: PropType<NotificationItemType>;
+        default: string;
+    };
+    placement: import("vue-types").VueTypeDef<string> & {
+        default: string;
+    };
+    closable: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    duration: import("vue-types").VueTypeValidableDef<number> & {
+        default: number;
+    } & {
+        default: number;
+    };
+    showIcon: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    title: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+    content: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+    closeText: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+    messageId: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+    colorful: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    onClose: import("vue-types").VueTypeValidableDef<(...args: any[]) => any> & {
+        default: (...args: any[]) => any;
+    };
+}>> & {
+    onAfterClose?: (...args: any[]) => any;
+}, {
+    type: NotificationItemType;
+    title: string;
+    onClose: (...args: any[]) => any;
+    closable: boolean;
+    showIcon: boolean;
+    content: string;
+    closeText: string;
+    duration: number;
+    placement: string;
+    messageId: string;
+    colorful: boolean;
+}>;
+export default _default;