element-plus 1.3.0-beta.3 → 1.3.0-beta.4

package/lib/packages/components/loading/src/types.d.ts

@@ -0,0 +1,23 @@
+import type { MaybeRef } from '@vueuse/core';
+export declare type LoadingOptionsResolved = {
+    parent: LoadingParentElement;
+    background: MaybeRef<string>;
+    svg: MaybeRef<string>;
+    svgViewBox: MaybeRef<string>;
+    spinner: MaybeRef<boolean | string>;
+    text: MaybeRef<string>;
+    fullscreen: boolean;
+    lock: boolean;
+    customClass: MaybeRef<string>;
+    visible: boolean;
+    target: HTMLElement;
+    beforeClose?: () => boolean;
+    closed?: () => void;
+};
+export declare type LoadingOptions = Partial<Omit<LoadingOptionsResolved, 'parent' | 'target'> & {
+    target: HTMLElement | string;
+    body: boolean;
+}>;
+export interface LoadingParentElement extends HTMLElement {
+    vLoadingAddClassList?: () => void;
+}

package/lib/packages/components/loading/style/css.d.ts

@@ -0,0 +1,2 @@
+import 'element-plus/es/components/base/style/css';
+import 'element-plus/theme-chalk/el-loading.css';

package/lib/packages/components/loading/style/index.d.ts

@@ -0,0 +1,2 @@
+import 'element-plus/es/components/base/style';
+import 'element-plus/theme-chalk/src/loading.scss';

package/lib/packages/components/main/style/css.d.ts

@@ -0,0 +1,2 @@
+import 'element-plus/es/components/base/style/css';
+import 'element-plus/theme-chalk/el-main.css';

package/lib/packages/components/main/style/index.d.ts

@@ -0,0 +1,2 @@
+import 'element-plus/es/components/base/style';
+import 'element-plus/theme-chalk/src/main.scss';

package/lib/packages/components/menu/src/menu-collapse-transition.vue.d.ts

@@ -0,0 +1,5 @@
+import type { TransitionProps } from 'vue';
+declare const _default: import("vue").DefineComponent<{}, {
+    listeners: TransitionProps;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{} & {} & {}>, {}>;
+export default _default;

package/lib/packages/components/menu/src/menu-item-group.d.ts

@@ -0,0 +1,5 @@
+import type { ExtractPropTypes } from 'vue';
+export declare const menuItemGroupProps: {
+    readonly title: StringConstructor;
+};
+export declare type MenuItemGroupProps = ExtractPropTypes<typeof menuItemGroupProps>;

package/lib/packages/components/menu/src/menu-item-group.vue.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("vue").DefineComponent<{
+    readonly title: StringConstructor;
+}, {
+    levelPadding: import("vue").ComputedRef<number>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
+    readonly title?: unknown;
+} & {} & {
+    title?: string | undefined;
+}>, {}>;
+export default _default;

package/lib/packages/components/menu/src/menu-item.d.ts

@@ -0,0 +1,13 @@
+import type { ExtractPropTypes } from 'vue';
+import type { RouteLocationRaw } from 'vue-router';
+import type { MenuItemRegistered } from './types';
+export declare const menuItemProps: {
+    readonly index: import("element-plus/es/utils/props").BuildPropReturn<import("element-plus/es/utils/props").PropWrapper<string | null>, null, unknown, unknown, unknown>;
+    readonly route: import("element-plus/es/utils/props").BuildPropReturn<import("element-plus/es/utils/props").PropWrapper<RouteLocationRaw>, unknown, unknown, unknown, unknown>;
+    readonly disabled: BooleanConstructor;
+};
+export declare type MenuItemProps = ExtractPropTypes<typeof menuItemProps>;
+export declare const menuItemEmits: {
+    click: (item: MenuItemRegistered) => boolean;
+};
+export declare type MenuItemEmits = typeof menuItemEmits;

package/lib/packages/components/menu/src/menu.d.ts

@@ -0,0 +1,86 @@
+import type { MenuItemClicked } from './types';
+import type { NavigationFailure } from 'vue-router';
+import type { VNode, ExtractPropTypes } from 'vue';
+export declare const menuProps: {
+    readonly mode: import("element-plus/es/utils/props").BuildPropReturn<StringConstructor, "vertical", unknown, "horizontal" | "vertical", unknown>;
+    readonly defaultActive: import("element-plus/es/utils/props").BuildPropReturn<StringConstructor, "", unknown, unknown, unknown>;
+    readonly defaultOpeneds: import("element-plus/es/utils/props").BuildPropReturn<import("element-plus/es/utils/props").PropWrapper<string[]>, () => [], unknown, unknown, unknown>;
+    readonly uniqueOpened: BooleanConstructor;
+    readonly router: BooleanConstructor;
+    readonly menuTrigger: import("element-plus/es/utils/props").BuildPropReturn<StringConstructor, "hover", unknown, "click" | "hover", unknown>;
+    readonly collapse: BooleanConstructor;
+    readonly backgroundColor: StringConstructor;
+    readonly textColor: StringConstructor;
+    readonly activeTextColor: StringConstructor;
+    readonly collapseTransition: import("element-plus/es/utils/props").BuildPropReturn<BooleanConstructor, true, unknown, unknown, unknown>;
+    readonly ellipsis: import("element-plus/es/utils/props").BuildPropReturn<BooleanConstructor, true, unknown, unknown, unknown>;
+};
+export declare type MenuProps = ExtractPropTypes<typeof menuProps>;
+export declare const menuEmits: {
+    close: (index: string, indexPath: string[]) => boolean;
+    open: (index: string, indexPath: string[]) => boolean;
+    select: (index: string, indexPath: string[], item: MenuItemClicked, routerResult?: Promise<void | NavigationFailure> | undefined) => boolean;
+};
+export declare type MenuEmits = typeof menuEmits;
+declare const _default: import("vue").DefineComponent<{
+    readonly mode: import("element-plus/es/utils/props").BuildPropReturn<StringConstructor, "vertical", unknown, "horizontal" | "vertical", unknown>;
+    readonly defaultActive: import("element-plus/es/utils/props").BuildPropReturn<StringConstructor, "", unknown, unknown, unknown>;
+    readonly defaultOpeneds: import("element-plus/es/utils/props").BuildPropReturn<import("element-plus/es/utils/props").PropWrapper<string[]>, () => [], unknown, unknown, unknown>;
+    readonly uniqueOpened: BooleanConstructor;
+    readonly router: BooleanConstructor;
+    readonly menuTrigger: import("element-plus/es/utils/props").BuildPropReturn<StringConstructor, "hover", unknown, "click" | "hover", unknown>;
+    readonly collapse: BooleanConstructor;
+    readonly backgroundColor: StringConstructor;
+    readonly textColor: StringConstructor;
+    readonly activeTextColor: StringConstructor;
+    readonly collapseTransition: import("element-plus/es/utils/props").BuildPropReturn<BooleanConstructor, true, unknown, unknown, unknown>;
+    readonly ellipsis: import("element-plus/es/utils/props").BuildPropReturn<BooleanConstructor, true, unknown, unknown, unknown>;
+}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: (index: string, indexPath: string[]) => boolean;
+    open: (index: string, indexPath: string[]) => boolean;
+    select: (index: string, indexPath: string[], item: MenuItemClicked, routerResult?: Promise<void | NavigationFailure> | undefined) => boolean;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
+    readonly mode?: unknown;
+    readonly defaultActive?: unknown;
+    readonly defaultOpeneds?: unknown;
+    readonly uniqueOpened?: unknown;
+    readonly router?: unknown;
+    readonly menuTrigger?: unknown;
+    readonly collapse?: unknown;
+    readonly backgroundColor?: unknown;
+    readonly textColor?: unknown;
+    readonly activeTextColor?: unknown;
+    readonly collapseTransition?: unknown;
+    readonly ellipsis?: unknown;
+} & {
+    ellipsis: import("element-plus/es/utils/props").BuildPropType<BooleanConstructor, unknown, unknown>;
+    collapse: boolean;
+    mode: import("element-plus/es/utils/props").BuildPropType<StringConstructor, "horizontal" | "vertical", unknown>;
+    defaultActive: string;
+    defaultOpeneds: string[];
+    menuTrigger: import("element-plus/es/utils/props").BuildPropType<StringConstructor, "click" | "hover", unknown>;
+    collapseTransition: import("element-plus/es/utils/props").BuildPropType<BooleanConstructor, unknown, unknown>;
+    uniqueOpened: boolean;
+    router: boolean;
+} & {
+    textColor?: string | undefined;
+    backgroundColor?: string | undefined;
+    activeTextColor?: string | undefined;
+}> & {
+    onClose?: ((index: string, indexPath: string[]) => any) | undefined;
+    onOpen?: ((index: string, indexPath: string[]) => any) | undefined;
+    onSelect?: ((index: string, indexPath: string[], item: MenuItemClicked, routerResult?: Promise<void | NavigationFailure> | undefined) => any) | undefined;
+}, {
+    ellipsis: import("element-plus/es/utils/props").BuildPropType<BooleanConstructor, unknown, unknown>;
+    collapse: boolean;
+    mode: import("element-plus/es/utils/props").BuildPropType<StringConstructor, "horizontal" | "vertical", unknown>;
+    defaultActive: string;
+    defaultOpeneds: string[];
+    menuTrigger: import("element-plus/es/utils/props").BuildPropType<StringConstructor, "click" | "hover", unknown>;
+    collapseTransition: import("element-plus/es/utils/props").BuildPropType<BooleanConstructor, unknown, unknown>;
+    uniqueOpened: boolean;
+    router: boolean;
+}>;
+export default _default;

package/lib/packages/components/menu/src/sub-menu.d.ts

@@ -0,0 +1,41 @@
+import type { ExtractPropTypes } from 'vue';
+export declare const subMenuProps: {
+    readonly index: import("element-plus/es/utils/props").BuildPropReturn<StringConstructor, unknown, true, unknown, unknown>;
+    readonly showTimeout: import("element-plus/es/utils/props").BuildPropReturn<NumberConstructor, 300, unknown, unknown, unknown>;
+    readonly hideTimeout: import("element-plus/es/utils/props").BuildPropReturn<NumberConstructor, 300, unknown, unknown, unknown>;
+    readonly popperClass: StringConstructor;
+    readonly disabled: BooleanConstructor;
+    readonly popperAppendToBody: import("element-plus/es/utils/props").BuildPropReturn<BooleanConstructor, undefined, unknown, unknown, unknown>;
+};
+export declare type SubMenuProps = ExtractPropTypes<typeof subMenuProps>;
+declare const _default: import("vue").DefineComponent<{
+    readonly index: import("element-plus/es/utils/props").BuildPropReturn<StringConstructor, unknown, true, unknown, unknown>;
+    readonly showTimeout: import("element-plus/es/utils/props").BuildPropReturn<NumberConstructor, 300, unknown, unknown, unknown>;
+    readonly hideTimeout: import("element-plus/es/utils/props").BuildPropReturn<NumberConstructor, 300, unknown, unknown, unknown>;
+    readonly popperClass: StringConstructor;
+    readonly disabled: BooleanConstructor;
+    readonly popperAppendToBody: import("element-plus/es/utils/props").BuildPropReturn<BooleanConstructor, undefined, unknown, unknown, unknown>;
+}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
+    readonly index?: unknown;
+    readonly showTimeout?: unknown;
+    readonly hideTimeout?: unknown;
+    readonly popperClass?: unknown;
+    readonly disabled?: unknown;
+    readonly popperAppendToBody?: unknown;
+} & {
+    disabled: boolean;
+    index: string;
+    showTimeout: number;
+    hideTimeout: number;
+} & {
+    popperClass?: string | undefined;
+    popperAppendToBody?: import("element-plus/es/utils/props").BuildPropType<BooleanConstructor, unknown, unknown> | undefined;
+}>, {
+    disabled: boolean;
+    popperAppendToBody: import("element-plus/es/utils/props").BuildPropType<BooleanConstructor, unknown, unknown>;
+    showTimeout: number;
+    hideTimeout: number;
+}>;
+export default _default;

package/lib/packages/components/menu/src/types.d.ts

@@ -0,0 +1,35 @@
+import type { Ref } from 'vue';
+import type { RouteLocationRaw } from 'vue-router';
+import type { MenuProps } from './menu';
+export interface MenuItemRegistered {
+    index: string;
+    indexPath: string[];
+    active: boolean;
+}
+export interface MenuItemClicked {
+    index: string;
+    indexPath: string[];
+    route?: RouteLocationRaw;
+}
+export interface MenuProvider {
+    openedMenus: string[];
+    items: Record<string, MenuItemRegistered>;
+    subMenus: Record<string, MenuItemRegistered>;
+    activeIndex?: string;
+    isMenuPopup: boolean;
+    props: MenuProps;
+    addMenuItem: (item: MenuItemRegistered) => void;
+    removeMenuItem: (item: MenuItemRegistered) => void;
+    addSubMenu: (item: MenuItemRegistered) => void;
+    removeSubMenu: (item: MenuItemRegistered) => void;
+    openMenu: (index: string, indexPath: string[]) => void;
+    closeMenu: (index: string, indexPath: string[]) => void;
+    handleMenuItemClick: (item: MenuItemClicked) => void;
+    handleSubMenuClick: (subMenu: MenuItemRegistered) => void;
+}
+export interface SubMenuProvider {
+    addSubMenu: (item: MenuItemRegistered) => void;
+    removeSubMenu: (item: MenuItemRegistered) => void;
+    handleMouseleave?: (deepDispatch: boolean) => void;
+    mouseInChild: Ref<boolean>;
+}

package/lib/packages/components/menu/src/use-menu-color.d.ts

@@ -0,0 +1,2 @@
+import type { MenuProps } from './menu';
+export default function useMenuColor(props: MenuProps): import("vue").ComputedRef<string>;

package/lib/packages/components/menu/src/use-menu-css-var.d.ts

@@ -0,0 +1,8 @@
+import type { MenuProps } from './menu';
+export declare const useMenuCssVar: (props: MenuProps) => import("vue").ComputedRef<{
+    '--el-menu-text-color': string;
+    '--el-menu-hover-text-color': string;
+    '--el-menu-bg-color': string;
+    '--el-menu-hover-bg-color': string;
+    '--el-menu-active-color': string;
+}>;

package/lib/packages/components/menu/src/use-menu.d.ts

@@ -0,0 +1,6 @@
+import type { ComponentInternalInstance, Ref, CSSProperties } from 'vue';
+export default function useMenu(instance: ComponentInternalInstance, currentIndex: Ref<string>): {
+    parentMenu: import("vue").ComputedRef<ComponentInternalInstance>;
+    paddingStyle: import("vue").ComputedRef<CSSProperties>;
+    indexPath: import("vue").ComputedRef<string[]>;
+};

package/lib/packages/components/menu/style/css.d.ts

@@ -0,0 +1,3 @@
+import 'element-plus/es/components/base/style/css';
+import 'element-plus/theme-chalk/el-menu.css';
+import 'element-plus/es/components/tooltip/style/css';

package/lib/packages/components/menu/style/index.d.ts

@@ -0,0 +1,3 @@
+import 'element-plus/es/components/base/style';
+import 'element-plus/theme-chalk/src/menu.scss';
+import 'element-plus/es/components/tooltip/style/index';

package/lib/packages/components/message/index.d.ts

@@ -0,0 +1,3 @@
+export declare const ElMessage: import("../../utils/types").SFCWithInstall<import("./src/message").Message>;
+export default ElMessage;
+export * from './src/message';

package/lib/packages/components/message/src/message-method.d.ts

@@ -0,0 +1,6 @@
+import type { Message } from './message';
+import type { VNode } from 'vue';
+export declare function close(id: string, userOnClose?: (vm: VNode) => void): void;
+export declare function closeAll(): void;
+declare const _default: Message;
+export default _default;

package/lib/packages/components/message/src/message.d.ts

@@ -0,0 +1,52 @@
+import type { VNode, ExtractPropTypes, Component } from 'vue';
+export declare const messageTypes: readonly ["success", "info", "warning", "error"];
+export interface MessageConfigContext {
+    max?: number;
+}
+export declare const messageProps: {
+    readonly customClass: import("element-plus/es/utils/props").BuildPropReturn<StringConstructor, "", unknown, unknown, unknown>;
+    readonly center: import("element-plus/es/utils/props").BuildPropReturn<BooleanConstructor, false, unknown, unknown, unknown>;
+    readonly dangerouslyUseHTMLString: import("element-plus/es/utils/props").BuildPropReturn<BooleanConstructor, false, unknown, unknown, unknown>;
+    readonly duration: import("element-plus/es/utils/props").BuildPropReturn<NumberConstructor, 3000, unknown, unknown, unknown>;
+    readonly icon: import("element-plus/es/utils/props").BuildPropReturn<import("element-plus/es/utils/props").PropWrapper<string | Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>>, "", unknown, unknown, unknown>;
+    readonly id: import("element-plus/es/utils/props").BuildPropReturn<StringConstructor, "", unknown, unknown, unknown>;
+    readonly message: import("element-plus/es/utils/props").BuildPropReturn<import("element-plus/es/utils/props").PropWrapper<string | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>>, "", unknown, unknown, unknown>;
+    readonly onClose: import("element-plus/es/utils/props").BuildPropReturn<import("element-plus/es/utils/props").PropWrapper<() => void>, unknown, false, unknown, unknown>;
+    readonly showClose: import("element-plus/es/utils/props").BuildPropReturn<BooleanConstructor, false, unknown, unknown, unknown>;
+    readonly type: import("element-plus/es/utils/props").BuildPropReturn<StringConstructor, "info", unknown, "success" | "warning" | "info" | "error", unknown>;
+    readonly offset: import("element-plus/es/utils/props").BuildPropReturn<NumberConstructor, 20, unknown, unknown, unknown>;
+    readonly zIndex: import("element-plus/es/utils/props").BuildPropReturn<NumberConstructor, 0, unknown, unknown, unknown>;
+    readonly grouping: import("element-plus/es/utils/props").BuildPropReturn<BooleanConstructor, false, unknown, unknown, unknown>;
+    readonly repeatNum: import("element-plus/es/utils/props").BuildPropReturn<NumberConstructor, 1, unknown, unknown, unknown>;
+};
+export declare type MessageProps = ExtractPropTypes<typeof messageProps>;
+export declare const messageEmits: {
+    destroy: () => boolean;
+};
+export declare type MessageEmits = typeof messageEmits;
+export declare type MessageOptions = Omit<MessageProps, 'id'> & {
+    appendTo?: HTMLElement | string;
+};
+export declare type MessageOptionsTyped = Omit<MessageOptions, 'type'>;
+export interface MessageHandle {
+    close: () => void;
+}
+export declare type MessageParams = Partial<MessageOptions> | string | VNode;
+export declare type MessageParamsTyped = Partial<MessageOptionsTyped> | string | VNode;
+export declare type MessageFn = ((options?: MessageParams) => MessageHandle) & {
+    closeAll(): void;
+};
+export declare type MessageTypedFn = (options?: MessageParamsTyped) => MessageHandle;
+export interface Message extends MessageFn {
+    success: MessageTypedFn;
+    warning: MessageTypedFn;
+    info: MessageTypedFn;
+    error: MessageTypedFn;
+}
+declare type MessageQueueItem = {
+    vm: VNode;
+};
+export declare type MessageQueue = MessageQueueItem[];
+export {};

package/lib/packages/components/message/src/message.vue.d.ts

@@ -0,0 +1,83 @@
+import type { CSSProperties } from 'vue';
+declare const _default: import("vue").DefineComponent<{
+    readonly customClass: import("../../../utils/props").BuildPropReturn<StringConstructor, "", unknown, unknown, unknown>;
+    readonly center: import("../../../utils/props").BuildPropReturn<BooleanConstructor, false, unknown, unknown, unknown>;
+    readonly dangerouslyUseHTMLString: import("../../../utils/props").BuildPropReturn<BooleanConstructor, false, unknown, unknown, unknown>;
+    readonly duration: import("../../../utils/props").BuildPropReturn<NumberConstructor, 3000, unknown, unknown, unknown>;
+    readonly icon: import("../../../utils/props").BuildPropReturn<import("../../../utils/props").PropWrapper<string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>>, "", unknown, unknown, unknown>;
+    readonly id: import("../../../utils/props").BuildPropReturn<StringConstructor, "", unknown, unknown, unknown>;
+    readonly message: import("../../../utils/props").BuildPropReturn<import("../../../utils/props").PropWrapper<string | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>>, "", unknown, unknown, unknown>;
+    readonly onClose: import("../../../utils/props").BuildPropReturn<import("../../../utils/props").PropWrapper<() => void>, unknown, false, unknown, unknown>;
+    readonly showClose: import("../../../utils/props").BuildPropReturn<BooleanConstructor, false, unknown, unknown, unknown>;
+    readonly type: import("../../../utils/props").BuildPropReturn<StringConstructor, "info", unknown, "success" | "warning" | "info" | "error", unknown>;
+    readonly offset: import("../../../utils/props").BuildPropReturn<NumberConstructor, 20, unknown, unknown, unknown>;
+    readonly zIndex: import("../../../utils/props").BuildPropReturn<NumberConstructor, 0, unknown, unknown, unknown>;
+    readonly grouping: import("../../../utils/props").BuildPropReturn<BooleanConstructor, false, unknown, unknown, unknown>;
+    readonly repeatNum: import("../../../utils/props").BuildPropReturn<NumberConstructor, 1, unknown, unknown, unknown>;
+}, {
+    typeClass: import("vue").ComputedRef<string>;
+    iconComponent: import("vue").ComputedRef<import("../../../utils/props").BuildPropType<import("../../../utils/props").PropWrapper<string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>>, unknown, unknown>>;
+    customStyle: import("vue").ComputedRef<CSSProperties>;
+    visible: import("vue").Ref<boolean>;
+    badgeType: import("vue").Ref<import("../../../utils/props").BuildPropType<StringConstructor, "primary" | "success" | "warning" | "info" | "danger", unknown>>;
+    close: () => void;
+    clearTimer: () => void;
+    startTimer: () => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    destroy: () => boolean;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
+    readonly customClass?: unknown;
+    readonly center?: unknown;
+    readonly dangerouslyUseHTMLString?: unknown;
+    readonly duration?: unknown;
+    readonly icon?: unknown;
+    readonly id?: unknown;
+    readonly message?: unknown;
+    readonly onClose?: unknown;
+    readonly showClose?: unknown;
+    readonly type?: unknown;
+    readonly offset?: unknown;
+    readonly zIndex?: unknown;
+    readonly grouping?: unknown;
+    readonly repeatNum?: unknown;
+} & {
+    type: import("../../../utils/props").BuildPropType<StringConstructor, "success" | "warning" | "info" | "error", unknown>;
+    icon: import("../../../utils/props").BuildPropType<import("../../../utils/props").PropWrapper<string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>>, unknown, unknown>;
+    message: import("../../../utils/props").BuildPropType<import("../../../utils/props").PropWrapper<string | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>>, unknown, unknown>;
+    zIndex: number;
+    offset: number;
+    center: import("../../../utils/props").BuildPropType<BooleanConstructor, unknown, unknown>;
+    id: string;
+    showClose: import("../../../utils/props").BuildPropType<BooleanConstructor, unknown, unknown>;
+    customClass: string;
+    duration: number;
+    dangerouslyUseHTMLString: import("../../../utils/props").BuildPropType<BooleanConstructor, unknown, unknown>;
+    grouping: import("../../../utils/props").BuildPropType<BooleanConstructor, unknown, unknown>;
+    repeatNum: number;
+} & {
+    onClose?: (() => void) | undefined;
+}> & {
+    onDestroy?: (() => any) | undefined;
+}, {
+    type: import("../../../utils/props").BuildPropType<StringConstructor, "success" | "warning" | "info" | "error", unknown>;
+    icon: import("../../../utils/props").BuildPropType<import("../../../utils/props").PropWrapper<string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>>, unknown, unknown>;
+    message: import("../../../utils/props").BuildPropType<import("../../../utils/props").PropWrapper<string | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>>, unknown, unknown>;
+    zIndex: number;
+    offset: number;
+    center: import("../../../utils/props").BuildPropType<BooleanConstructor, unknown, unknown>;
+    onClose: () => void;
+    id: string;
+    showClose: import("../../../utils/props").BuildPropType<BooleanConstructor, unknown, unknown>;
+    customClass: string;
+    duration: number;
+    dangerouslyUseHTMLString: import("../../../utils/props").BuildPropType<BooleanConstructor, unknown, unknown>;
+    grouping: import("../../../utils/props").BuildPropType<BooleanConstructor, unknown, unknown>;
+    repeatNum: number;
+}>;
+export default _default;

package/lib/packages/components/message/style/css.d.ts

@@ -0,0 +1,2 @@
+import 'element-plus/es/components/base/style/css';
+import 'element-plus/theme-chalk/el-message.css';

package/lib/packages/components/message/style/index.d.ts

@@ -0,0 +1,2 @@
+import 'element-plus/es/components/base/style';
+import 'element-plus/theme-chalk/src/message.scss';

package/lib/packages/components/message-box/index.d.ts

@@ -0,0 +1,5 @@
+import type { SFCWithInstall } from 'element-plus/es/utils/types';
+declare const _MessageBox: SFCWithInstall<import("./src/message-box.type").IElMessageBox>;
+export default _MessageBox;
+export declare const ElMessageBox: SFCWithInstall<import("./src/message-box.type").IElMessageBox>;
+export * from './src/message-box.type';

package/lib/{components → packages/components}/message-box/src/index.vue.d.ts

@@ -1810,12 +1810,12 @@ declare const _default: import("vue").DefineComponent<{
     boxType?: unknown;
 } & {
     center: boolean;
-    container: string;
     showClose: boolean;
     closeOnClickModal: boolean;
     closeOnPressEscape: boolean;
     lockScroll: boolean;
     modal: boolean;
+    container: string;
     closeOnHashChange: boolean;
     roundButton: boolean;
     boxType: MessageBoxType;
@@ -1826,12 +1826,12 @@ declare const _default: import("vue").DefineComponent<{
     onAction?: ((...args: any[]) => any) | undefined;
 }, {
     center: boolean;
-    container: string;
     showClose: boolean;
     closeOnClickModal: boolean;
     closeOnPressEscape: boolean;
     lockScroll: boolean;
     modal: boolean;
+    container: string;
     closeOnHashChange: boolean;
     roundButton: boolean;
     boxType: MessageBoxType;

package/lib/packages/components/message-box/src/message-box.type.d.ts

@@ -0,0 +1,127 @@
+import type { CSSProperties, VNode, Component } from 'vue';
+declare type MessageType = '' | 'success' | 'warning' | 'info' | 'error';
+export declare type Action = 'confirm' | 'close' | 'cancel';
+export declare type MessageBoxType = '' | 'prompt' | 'alert' | 'confirm';
+export declare type MessageBoxData = MessageBoxInputData & Action;
+export interface MessageBoxInputData {
+    value: string;
+    action: Action;
+}
+export interface MessageBoxInputValidator {
+    (value: string): boolean | string;
+}
+export declare interface MessageBoxState {
+    title: string;
+    message: string;
+    type: MessageType;
+    icon: string | Component;
+    customClass: string;
+    customStyle: CSSProperties;
+    showInput: boolean;
+    inputValue: string;
+    inputPlaceholder: string;
+    inputType: string;
+    inputPattern: RegExp;
+    inputValidator: MessageBoxInputValidator;
+    inputErrorMessage: string;
+    showConfirmButton: boolean;
+    showCancelButton: boolean;
+    action: Action;
+    dangerouslyUseHTMLString: boolean;
+    confirmButtonText: string;
+    cancelButtonText: string;
+    confirmButtonLoading: boolean;
+    cancelButtonLoading: boolean;
+    confirmButtonClass: string;
+    confirmButtonDisabled: boolean;
+    cancelButtonClass: string;
+    editorErrorMessage: string;
+    beforeClose: null | ((action: Action, instance: MessageBoxState, done: () => void) => void);
+    callback: null | Callback;
+    distinguishCancelAndClose: boolean;
+    modalFade: boolean;
+    modalClass: string;
+    validateError: boolean;
+    zIndex: number;
+}
+export declare type Callback = ((value: string, action: Action) => any) | ((action: Action) => any);
+/** Options used in MessageBox */
+export interface ElMessageBoxOptions {
+    /** Callback before MessageBox closes, and it will prevent MessageBox from closing */
+    beforeClose?: (action: Action, instance: MessageBoxState, done: () => void) => void;
+    /** Custom class name for MessageBox */
+    customClass?: string;
+    /** Custom inline style for MessageBox */
+    customStyle?: CSSProperties;
+    /** MessageBox closing callback if you don't prefer Promise */
+    callback?: Callback;
+    /** Text content of cancel button */
+    cancelButtonText?: string;
+    /** Text content of confirm button */
+    confirmButtonText?: string;
+    /** Custom class name of cancel button */
+    cancelButtonClass?: string;
+    /** Custom class name of confirm button */
+    confirmButtonClass?: string;
+    /** Whether to align the content in center */
+    center?: boolean;
+    /** Content of the MessageBox */
+    message?: string | VNode;
+    /** Title of the MessageBox */
+    title?: string;
+    /** Message type, used for icon display */
+    type?: MessageType;
+    /** Message box type */
+    boxType?: MessageBoxType;
+    /** Custom icon component */
+    icon?: string | Component;
+    /** Whether message is treated as HTML string */
+    dangerouslyUseHTMLString?: boolean;
+    /** Whether to distinguish canceling and closing */
+    distinguishCancelAndClose?: boolean;
+    /** Whether to lock body scroll when MessageBox prompts */
+    lockScroll?: boolean;
+    /** Whether to show a cancel button */
+    showCancelButton?: boolean;
+    /** Whether to show a confirm button */
+    showConfirmButton?: boolean;
+    /** Whether to show a close button */
+    showClose?: boolean;
+    /** Whether to use round button */
+    roundButton?: boolean;
+    /** Whether MessageBox can be closed by clicking the mask */
+    closeOnClickModal?: boolean;
+    /** Whether MessageBox can be closed by pressing the ESC */
+    closeOnPressEscape?: boolean;
+    /** Whether to close MessageBox when hash changes */
+    closeOnHashChange?: boolean;
+    /** Whether to show an input */
+    showInput?: boolean;
+    /** Placeholder of input */
+    inputPlaceholder?: string;
+    /** Initial value of input */
+    inputValue?: string;
+    /** Regexp for the input */
+    inputPattern?: RegExp;
+    /** Input Type: text, textArea, password or number */
+    inputType?: string;
+    /** Validation function for the input. Should returns a boolean or string. If a string is returned, it will be assigned to inputErrorMessage */
+    inputValidator?: MessageBoxInputValidator;
+    /** Error message when validation fails */
+    inputErrorMessage?: string;
+}
+export declare type ElMessageBoxShortcutMethod = ((message: ElMessageBoxOptions['message'], title: ElMessageBoxOptions['title'], options?: ElMessageBoxOptions) => Promise<MessageBoxData>) & ((message: ElMessageBoxOptions['message'], options?: ElMessageBoxOptions) => Promise<MessageBoxData>);
+export interface IElMessageBox {
+    /** Show a message box */
+    /** Show a message box */
+    (options: ElMessageBoxOptions): Promise<MessageBoxData>;
+    /** Show an alert message box */
+    alert: ElMessageBoxShortcutMethod;
+    /** Show a confirm message box */
+    confirm: ElMessageBoxShortcutMethod;
+    /** Show a prompt message box */
+    prompt: ElMessageBoxShortcutMethod;
+    /** Close current message box */
+    close(): void;
+}
+export {};

package/lib/packages/components/message-box/src/messageBox.d.ts

@@ -0,0 +1,3 @@
+import type { IElMessageBox } from './message-box.type';
+declare const _default: IElMessageBox;
+export default _default;

package/lib/packages/components/message-box/style/css.d.ts

@@ -0,0 +1,5 @@
+import 'element-plus/es/components/base/style/css';
+import 'element-plus/theme-chalk/el-message-box.css';
+import 'element-plus/es/components/button/style/css';
+import 'element-plus/es/components/input/style/css';
+import 'element-plus/es/components/overlay/style/css';