yuang-framework-ui-pc 1.0.20 → 1.2.1

package/README.md

@@ -1,61 +1,37 @@
-# vue3-demo
+# EleAdminPlus
 
-This template should help get you started developing with Vue 3 in Vite.
+https://eleadmin.com
 
-## Recommended IDE Setup
+## 安装
 
-[VSCode](https://code.visualstudio.com/) + [Volar](https://marketplace.visualstudio.com/items?itemName=Vue.volar) (and disable Vetur).
-
-## Type Support for `.vue` Imports in TS
-
-TypeScript cannot handle type information for `.vue` imports by default, so we replace the `tsc` CLI with `vue-tsc` for type checking. In editors, we need [Volar](https://marketplace.visualstudio.com/items?itemName=Vue.volar) to make the TypeScript language service aware of `.vue` types.
-
-## Customize configuration
-
-See [Vite Configuration Reference](https://vitejs.dev/config/).
-
-## Project Setup
-
-```sh
-npm install
+```bash
+npm i --registry=https://registry.npmmirror.com
 ```
 
-### Compile and Hot-Reload for Development
+## 运行
 
-```sh
-npm run dev
-```
-
-### Type-Check, Compile and Minify for Production
+全局引入方式运行：
 
-```sh
-npm run build
 ```
-
-### Run Unit Tests with [Vitest](https://vitest.dev/)
-
-```sh
-npm run test:unit
+npm run dev
 ```
 
-### Run End-to-End Tests with [Cypress](https://www.cypress.io/)
+按需引入方式运行：
 
-```sh
-npm run test:e2e:dev
+```bash
+npm run dev:needed
 ```
 
-This runs the end-to-end tests against the Vite development server.
-It is much faster than the production build.
+## 打包
 
-But it's still recommended to test the production build with `test:e2e` before deploying (e.g. in CI environments):
+全部打包：
 
-```sh
+```bash
 npm run build
-npm run test:e2e
 ```
 
-### Lint with [ESLint](https://eslint.org/)
+打包指定组件：
 
-```sh
-npm run lint
+```bash
+npm run build src=/ele-alert
 ```

package/es/ele-admin-layout/components/layout-skeleton.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import('vue').DefineComponent<{
+    /** logo是否位于顶栏 */
+    isHeaderLogo: BooleanConstructor;
+}, unknown, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    /** logo是否位于顶栏 */
+    isHeaderLogo: BooleanConstructor;
+}>>, {
+    isHeaderLogo: boolean;
+}, {}>;
+export default _default;

package/es/ele-admin-layout/components/layout-skeleton.js

@@ -0,0 +1,47 @@
+import { defineComponent, resolveComponent, openBlock, createElementBlock, normalizeClass, renderSlot, createVNode, withCtx, createElementVNode } from "vue";
+import ReceiverView from "../../ele-config-provider/components/receiver-view";
+const _sfc_main = defineComponent({
+  name: "LayoutSkeleton",
+  components: { ReceiverView },
+  props: {
+    /** logo是否位于顶栏 */
+    isHeaderLogo: Boolean
+  }
+});
+const _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+const _hoisted_1 = { class: "ele-admin-body" };
+const _hoisted_2 = { class: "ele-admin-wrapper" };
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_ReceiverView = resolveComponent("ReceiverView");
+  return openBlock(), createElementBlock("div", {
+    class: normalizeClass(["ele-admin-layout", { "is-row-direction": !_ctx.isHeaderLogo }])
+  }, [
+    _ctx.isHeaderLogo ? renderSlot(_ctx.$slots, "head", { key: 0 }) : renderSlot(_ctx.$slots, "side", { key: 1 }),
+    createVNode(_component_ReceiverView, {
+      class: normalizeClass(["ele-admin-main", { "is-row-direction": _ctx.isHeaderLogo }]),
+      wrapPosition: false
+    }, {
+      default: withCtx(() => [
+        _ctx.isHeaderLogo ? renderSlot(_ctx.$slots, "side", { key: 0 }) : renderSlot(_ctx.$slots, "head", { key: 1 }),
+        createElementVNode("div", _hoisted_1, [
+          renderSlot(_ctx.$slots, "tabs"),
+          createElementVNode("div", _hoisted_2, [
+            renderSlot(_ctx.$slots, "body")
+          ])
+        ])
+      ]),
+      _: 3
+    }, 8, ["class"]),
+    renderSlot(_ctx.$slots, "default")
+  ], 2);
+}
+const layoutSkeleton = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+export {
+  layoutSkeleton as default
+};

package/es/ele-admin-layout/components/layout-tabs.d.ts

@@ -0,0 +1,64 @@
+import { PropType } from 'vue';
+import { EleDropdownProps } from '../../ele-app/plus';
+import { TabPaneItem, TabEventOption, ContextMenus } from '../../ele-tabs/types';
+import { TabStyle } from '../types';
+
+declare const _default: import('vue').DefineComponent<{
+    /** 页签数据 */
+    tabs: PropType<TabPaneItem[]>;
+    /** 页签选中 */
+    active: StringConstructor;
+    /** 是否需要固定的主页页签 */
+    fixedHome: BooleanConstructor;
+    /** 主页路由地址 */
+    homePath: StringConstructor;
+    /** 当前路由是否是主页 */
+    isHome: BooleanConstructor;
+    /** 页签风格 */
+    tabStyle: PropType<TabStyle>;
+    /** 是否支持右键菜单 */
+    tabContextMenu: PropType<boolean | EleDropdownProps>;
+    /** 右键菜单 */
+    tabContextMenus: PropType<ContextMenus>;
+    /** 是否支持拖动排序 */
+    tabSortable: BooleanConstructor;
+}, {
+    handleTabRemove: (name: string) => void;
+    handleTabItemClick: (option: TabEventOption) => void;
+    handleTabContextMenu: (option: TabEventOption) => void;
+    handleTabSortChange: (data: TabPaneItem[]) => void;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    tabClick: (_option: TabEventOption) => true;
+    tabRemove: (_name: string) => true;
+    tabContextMenu: (_option: TabEventOption) => true;
+    tabSortChange: (_data: TabPaneItem[]) => true;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    /** 页签数据 */
+    tabs: PropType<TabPaneItem[]>;
+    /** 页签选中 */
+    active: StringConstructor;
+    /** 是否需要固定的主页页签 */
+    fixedHome: BooleanConstructor;
+    /** 主页路由地址 */
+    homePath: StringConstructor;
+    /** 当前路由是否是主页 */
+    isHome: BooleanConstructor;
+    /** 页签风格 */
+    tabStyle: PropType<TabStyle>;
+    /** 是否支持右键菜单 */
+    tabContextMenu: PropType<boolean | EleDropdownProps>;
+    /** 右键菜单 */
+    tabContextMenus: PropType<ContextMenus>;
+    /** 是否支持拖动排序 */
+    tabSortable: BooleanConstructor;
+}>> & {
+    onTabClick?: ((_option: TabEventOption) => any) | undefined;
+    onTabRemove?: ((_name: string) => any) | undefined;
+    onTabContextMenu?: ((_option: TabEventOption) => any) | undefined;
+    onTabSortChange?: ((_data: TabPaneItem[]) => any) | undefined;
+}, {
+    fixedHome: boolean;
+    isHome: boolean;
+    tabSortable: boolean;
+}, {}>;
+export default _default;

package/es/ele-admin-layout/components/layout-tabs.js

@@ -0,0 +1,132 @@
+import { defineComponent, resolveComponent, openBlock, createBlock, withCtx, renderSlot, createVNode, createCommentVNode, createSlots, normalizeProps, guardReactiveProps } from "vue";
+import { ElIcon } from "element-plus";
+import { HomeOutlined } from "../../icons";
+import EleTabWrap from "../../ele-tab-wrap/index";
+import EleTabTool from "../../ele-tab-tool/index";
+import EleTabs from "../../ele-tabs/index";
+const _sfc_main = defineComponent({
+  name: "LayoutTabs",
+  components: {
+    ElIcon,
+    HomeOutlined,
+    EleTabWrap,
+    EleTabTool,
+    EleTabs
+  },
+  props: {
+    /** 页签数据 */
+    tabs: Array,
+    /** 页签选中 */
+    active: String,
+    /** 是否需要固定的主页页签 */
+    fixedHome: Boolean,
+    /** 主页路由地址 */
+    homePath: String,
+    /** 当前路由是否是主页 */
+    isHome: Boolean,
+    /** 页签风格 */
+    tabStyle: String,
+    /** 是否支持右键菜单 */
+    tabContextMenu: [Boolean, Object],
+    /** 右键菜单 */
+    tabContextMenus: [Array, Function],
+    /** 是否支持拖动排序 */
+    tabSortable: Boolean
+  },
+  emits: {
+    tabClick: (_option) => true,
+    tabRemove: (_name) => true,
+    tabContextMenu: (_option) => true,
+    tabSortChange: (_data) => true
+  },
+  setup(_props, { emit }) {
+    const handleTabItemClick = (option) => {
+      emit("tabClick", option);
+    };
+    const handleTabRemove = (name) => {
+      emit("tabRemove", name);
+    };
+    const handleTabContextMenu = (option) => {
+      emit("tabContextMenu", option);
+    };
+    const handleTabSortChange = (data) => {
+      emit("tabSortChange", data);
+    };
+    return {
+      handleTabRemove,
+      handleTabItemClick,
+      handleTabContextMenu,
+      handleTabSortChange
+    };
+  }
+});
+const _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_HomeOutlined = resolveComponent("HomeOutlined");
+  const _component_ElIcon = resolveComponent("ElIcon");
+  const _component_EleTabTool = resolveComponent("EleTabTool");
+  const _component_EleTabs = resolveComponent("EleTabs");
+  const _component_EleTabWrap = resolveComponent("EleTabWrap");
+  return openBlock(), createBlock(_component_EleTabWrap, {
+    type: _ctx.tabStyle,
+    class: "ele-admin-tabs"
+  }, {
+    default: withCtx(() => [
+      _ctx.fixedHome ? (openBlock(), createBlock(_component_EleTabTool, {
+        key: 0,
+        tab: true,
+        active: _ctx.isHome,
+        tabName: _ctx.homePath
+      }, {
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "tabHome", { active: _ctx.active }, () => [
+            createVNode(_component_ElIcon, {
+              class: "ele-tab-icon",
+              style: { "vertical-align": "-3px" }
+            }, {
+              default: withCtx(() => [
+                createVNode(_component_HomeOutlined, { style: { "transform": "scale(1.08)" } })
+              ]),
+              _: 1
+            })
+          ])
+        ]),
+        _: 3
+      }, 8, ["active", "tabName"])) : createCommentVNode("", true),
+      _ctx.tabs ? (openBlock(), createBlock(_component_EleTabs, {
+        key: 1,
+        items: _ctx.tabs,
+        modelValue: _ctx.active,
+        sortable: _ctx.tabSortable,
+        contextMenu: _ctx.tabContextMenu,
+        contextMenus: _ctx.tabContextMenus,
+        mousewheel: true,
+        handleClick: true,
+        onTabRemove: _ctx.handleTabRemove,
+        onTabItemClick: _ctx.handleTabItemClick,
+        onTabContextMenu: _ctx.handleTabContextMenu,
+        onTabSortChange: _ctx.handleTabSortChange
+      }, createSlots({ _: 2 }, [
+        _ctx.$slots.tabTitle ? {
+          name: "label",
+          fn: withCtx((slotProps) => [
+            renderSlot(_ctx.$slots, "tabTitle", normalizeProps(guardReactiveProps(slotProps || {})))
+          ]),
+          key: "0"
+        } : void 0
+      ]), 1032, ["items", "modelValue", "sortable", "contextMenu", "contextMenus", "onTabRemove", "onTabItemClick", "onTabContextMenu", "onTabSortChange"])) : createCommentVNode("", true),
+      renderSlot(_ctx.$slots, "tabExtra", { active: _ctx.active })
+    ]),
+    _: 3
+  }, 8, ["type"]);
+}
+const layoutTabs = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+export {
+  layoutTabs as default
+};

package/es/ele-admin-layout/components/layout-tool.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{}>>, {}, {}>;
+export default _default;

package/es/ele-admin-layout/components/layout-tool.js

@@ -0,0 +1,21 @@
+import { defineComponent, openBlock, createElementBlock, renderSlot } from "vue";
+const _sfc_main = defineComponent({
+  name: "LayoutTool"
+});
+const _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+const _hoisted_1 = { class: "ele-admin-tool" };
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock("div", _hoisted_1, [
+    renderSlot(_ctx.$slots, "default")
+  ]);
+}
+const layoutTool = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+export {
+  layoutTool as default
+};

package/es/ele-admin-layout/index.d.ts

@@ -0,0 +1,293 @@
+import { EleMenusInstance } from '../ele-app/plus';
+import { MenuItem } from '../ele-menus/types';
+import { TabPaneItem, TabEventOption } from '../ele-tabs/types';
+
+declare const _default: import('vue').DefineComponent<{
+    height: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: string;
+    };
+    headerMenus: import('vue').PropType<MenuItem[]>;
+    headerActive: StringConstructor;
+    sidebarMenus: import('vue').PropType<MenuItem[]>;
+    sidebarActive: StringConstructor;
+    sideboxMenus: import('vue').PropType<MenuItem[]>;
+    sideboxActive: StringConstructor;
+    tabs: import('vue').PropType<TabPaneItem[]>;
+    tabActive: StringConstructor;
+    levels: import('vue').PropType<import('../ele-breadcrumb/types').BreadcrumbItem[]>;
+    collapse: BooleanConstructor;
+    compact: BooleanConstructor;
+    maximized: import('vue').PropType<import('./types').Maximized>;
+    tabBar: import('vue').PropType<import('./types').TabBar>;
+    breadcrumb: import('vue').PropType<boolean | import('../ele-app/plus').EleBreadcrumbProps>;
+    backTop: import('vue').PropType<boolean | import('../ele-app/plus').EleBacktopProps>;
+    headerMenuProps: import('vue').PropType<import('../ele-app/plus').EleMenusProps>;
+    sidebarMenuProps: import('vue').PropType<import('../ele-app/plus').EleMenusProps>;
+    sideboxMenuProps: import('vue').PropType<import('../ele-app/plus').EleMenusProps>;
+    layout: import('vue').PropType<import('./types').Layout>;
+    sidebarLayout: import('vue').PropType<import('./types').SidebarLayout>;
+    headerStyle: import('vue').PropType<import('./types').HeaderStyle>;
+    sidebarStyle: import('vue').PropType<import('./types').SidebarStyle>;
+    tabStyle: {
+        type: import('vue').PropType<import('./types').TabStyle>;
+        default: string;
+    };
+    fixedHeader: BooleanConstructor;
+    fixedSidebar: BooleanConstructor;
+    fixedBody: BooleanConstructor;
+    logoInHeader: BooleanConstructor;
+    fixedHome: BooleanConstructor;
+    homePath: StringConstructor;
+    isHome: BooleanConstructor;
+    tabContextMenu: import('vue').PropType<boolean | import('../ele-app/plus').EleDropdownProps>;
+    tabContextMenus: import('vue').PropType<import('../ele-tabs/types').ContextMenus>;
+    tabSortable: BooleanConstructor;
+    headerTitleSlot: {
+        type: StringConstructor;
+        default: string;
+    };
+    headerIconSlot: {
+        type: StringConstructor;
+        default: string;
+    };
+    sidebarTitleSlot: {
+        type: StringConstructor;
+        default: string;
+    };
+    sidebarIconSlot: {
+        type: StringConstructor;
+        default: string;
+    };
+    sideboxTitleSlot: {
+        type: StringConstructor;
+        default: string;
+    };
+    sideboxIconSlot: {
+        type: StringConstructor;
+        default: string;
+    };
+    headerCustomStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    sidebarCustomStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    sideboxCustomStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    tabsCustomStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    contentCustomStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    logoStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    logoTitleStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    headerMenusStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    sidebarMenusStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    sideboxMenusStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    logoSrc: StringConstructor;
+    logoTitle: StringConstructor;
+    menuScrollToActive: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    mobile: BooleanConstructor;
+}, {
+    ownSlots: string[];
+    tabSlots: string[];
+    sidebarMenuRef: import('vue').ShallowRef<EleMenusInstance>;
+    sideboxMenuRef: import('vue').ShallowRef<EleMenusInstance>;
+    contentRef: import('vue').ShallowRef<HTMLElement | null>;
+    modalsRef: import('vue').ShallowRef<HTMLElement | null>;
+    isDisableTransition: import('vue').ShallowRef<boolean>;
+    layoutHeight: import('vue').ComputedRef<string | undefined>;
+    isFixedHeader: import('vue').ComputedRef<boolean>;
+    isFixedSidebar: import('vue').ComputedRef<boolean>;
+    isTopLayout: import('vue').ComputedRef<boolean>;
+    isSideLayout: import('vue').ComputedRef<boolean>;
+    isBoxSidebar: import('vue').ComputedRef<boolean>;
+    isMixSidebar: import('vue').ComputedRef<boolean>;
+    isMobile: import('vue').ComputedRef<boolean>;
+    isHeaderLogo: import('vue').ComputedRef<boolean>;
+    showHeaderMenus: import('vue').ComputedRef<boolean>;
+    showHeaderTabs: import('vue').ComputedRef<boolean>;
+    isDarkHeader: import('vue').ComputedRef<boolean>;
+    isPrimaryHeader: import('vue').ComputedRef<boolean>;
+    isButtonTab: import('vue').ComputedRef<boolean>;
+    isDarkSidebar: import('vue').ComputedRef<boolean>;
+    isDarkMixSidebar: import('vue').ComputedRef<boolean>;
+    isGhostHeader: import('vue').ComputedRef<boolean>;
+    isGhostSidebar: import('vue').ComputedRef<boolean>;
+    isCollapseSidebar: import('vue').ComputedRef<boolean>;
+    isCollapseMobile: import('vue').ComputedRef<boolean>;
+    getContentEl: () => HTMLElement | null;
+    getModalsEl: () => HTMLElement | null;
+    updateCollapse: (value?: boolean) => void;
+    handleLogoClick: (e: MouseEvent) => void;
+    handleHeadMenuOpen: (index: string, indexPath: string[]) => void;
+    handleHeadMenuClose: (index: string, indexPath: string[]) => void;
+    handleHeadMenuItemClick: (item: MenuItem, e: MouseEvent) => void;
+    handleHeadMenuItemMouseenter: (item: MenuItem, e: MouseEvent) => void;
+    handleHeadMenuItemMouseleave: (item: MenuItem, e: MouseEvent) => void;
+    handleHeadMouseenter: (e: MouseEvent) => void;
+    handleHeadMouseleave: (e: MouseEvent) => void;
+    handleBoxMenuItemClick: (item: MenuItem, e: MouseEvent) => void;
+    handleBoxMenuItemMouseenter: (item: MenuItem, e: MouseEvent) => void;
+    handleBoxMenuItemMouseleave: (item: MenuItem, e: MouseEvent) => void;
+    handleBoxMouseEnter: (e: MouseEvent) => void;
+    handleBoxMouseLeave: (e: MouseEvent) => void;
+    handleSideMenuOpen: (index: string, indexPath: string[]) => void;
+    handleSideMenuClose: (index: string, indexPath: string[]) => void;
+    handleSideMenuItemClick: (item: MenuItem, e: MouseEvent) => void;
+    handleSideMouseEnter: (e: MouseEvent) => void;
+    handleSideMouseLeave: (e: MouseEvent) => void;
+    handleTabClick: (option: TabEventOption) => void;
+    handleTabRemove: (name: string) => void;
+    handleTabContextMenu: (option: TabEventOption) => void;
+    handleTabSortChange: (data: TabPaneItem[]) => void;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    'update:collapse': (_collapse: boolean) => boolean;
+    logoClick: (_e: MouseEvent) => boolean;
+    headMenuOpen: (_index: string, _indexPath: string[]) => boolean;
+    headMenuClose: (_index: string, _indexPath: string[]) => boolean;
+    headMenuItemClick: (_item: MenuItem, _e: MouseEvent) => boolean;
+    headMenuItemMouseenter: (_item: MenuItem, _e: MouseEvent) => boolean;
+    headMenuItemMouseleave: (_item: MenuItem, _e: MouseEvent) => boolean;
+    headMouseenter: (_e: MouseEvent) => boolean;
+    headMouseleave: (_e: MouseEvent) => boolean;
+    boxMenuItemClick: (_item: MenuItem, _e: MouseEvent) => boolean;
+    boxMenuItemMouseenter: (_item: MenuItem, _e: MouseEvent) => boolean;
+    boxMenuItemMouseleave: (_item: MenuItem, _e: MouseEvent) => boolean;
+    boxMouseenter: (_e: MouseEvent) => boolean;
+    boxMouseleave: (_e: MouseEvent) => boolean;
+    sideMenuOpen: (_index: string, _indexPath: string[]) => boolean;
+    sideMenuClose: (_index: string, _indexPath: string[]) => boolean;
+    sideMenuItemClick: (_item: MenuItem, _e: MouseEvent) => boolean;
+    sideMouseenter: (_e: MouseEvent) => boolean;
+    sideMouseleave: (_e: MouseEvent) => boolean;
+    tabClick: (_option: TabEventOption) => boolean;
+    tabRemove: (_name: string) => boolean;
+    tabContextMenu: (_option: TabEventOption) => boolean;
+    tabSortChange: (_data: TabPaneItem[]) => boolean;
+    contentMounted: (_contentEl: HTMLElement, _modalsEl: HTMLElement) => boolean;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    height: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: string;
+    };
+    headerMenus: import('vue').PropType<MenuItem[]>;
+    headerActive: StringConstructor;
+    sidebarMenus: import('vue').PropType<MenuItem[]>;
+    sidebarActive: StringConstructor;
+    sideboxMenus: import('vue').PropType<MenuItem[]>;
+    sideboxActive: StringConstructor;
+    tabs: import('vue').PropType<TabPaneItem[]>;
+    tabActive: StringConstructor;
+    levels: import('vue').PropType<import('../ele-breadcrumb/types').BreadcrumbItem[]>;
+    collapse: BooleanConstructor;
+    compact: BooleanConstructor;
+    maximized: import('vue').PropType<import('./types').Maximized>;
+    tabBar: import('vue').PropType<import('./types').TabBar>;
+    breadcrumb: import('vue').PropType<boolean | import('../ele-app/plus').EleBreadcrumbProps>;
+    backTop: import('vue').PropType<boolean | import('../ele-app/plus').EleBacktopProps>;
+    headerMenuProps: import('vue').PropType<import('../ele-app/plus').EleMenusProps>;
+    sidebarMenuProps: import('vue').PropType<import('../ele-app/plus').EleMenusProps>;
+    sideboxMenuProps: import('vue').PropType<import('../ele-app/plus').EleMenusProps>;
+    layout: import('vue').PropType<import('./types').Layout>;
+    sidebarLayout: import('vue').PropType<import('./types').SidebarLayout>;
+    headerStyle: import('vue').PropType<import('./types').HeaderStyle>;
+    sidebarStyle: import('vue').PropType<import('./types').SidebarStyle>;
+    tabStyle: {
+        type: import('vue').PropType<import('./types').TabStyle>;
+        default: string;
+    };
+    fixedHeader: BooleanConstructor;
+    fixedSidebar: BooleanConstructor;
+    fixedBody: BooleanConstructor;
+    logoInHeader: BooleanConstructor;
+    fixedHome: BooleanConstructor;
+    homePath: StringConstructor;
+    isHome: BooleanConstructor;
+    tabContextMenu: import('vue').PropType<boolean | import('../ele-app/plus').EleDropdownProps>;
+    tabContextMenus: import('vue').PropType<import('../ele-tabs/types').ContextMenus>;
+    tabSortable: BooleanConstructor;
+    headerTitleSlot: {
+        type: StringConstructor;
+        default: string;
+    };
+    headerIconSlot: {
+        type: StringConstructor;
+        default: string;
+    };
+    sidebarTitleSlot: {
+        type: StringConstructor;
+        default: string;
+    };
+    sidebarIconSlot: {
+        type: StringConstructor;
+        default: string;
+    };
+    sideboxTitleSlot: {
+        type: StringConstructor;
+        default: string;
+    };
+    sideboxIconSlot: {
+        type: StringConstructor;
+        default: string;
+    };
+    headerCustomStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    sidebarCustomStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    sideboxCustomStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    tabsCustomStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    contentCustomStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    logoStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    logoTitleStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    headerMenusStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    sidebarMenusStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    sideboxMenusStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    logoSrc: StringConstructor;
+    logoTitle: StringConstructor;
+    menuScrollToActive: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    mobile: BooleanConstructor;
+}>> & {
+    onTabClick?: ((_option: TabEventOption) => any) | undefined;
+    onTabRemove?: ((_name: string) => any) | undefined;
+    onTabContextMenu?: ((_option: TabEventOption) => any) | undefined;
+    onTabSortChange?: ((_data: TabPaneItem[]) => any) | undefined;
+    "onUpdate:collapse"?: ((_collapse: boolean) => any) | undefined;
+    onLogoClick?: ((_e: MouseEvent) => any) | undefined;
+    onHeadMenuOpen?: ((_index: string, _indexPath: string[]) => any) | undefined;
+    onHeadMenuClose?: ((_index: string, _indexPath: string[]) => any) | undefined;
+    onHeadMenuItemClick?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
+    onHeadMenuItemMouseenter?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
+    onHeadMenuItemMouseleave?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
+    onHeadMouseenter?: ((_e: MouseEvent) => any) | undefined;
+    onHeadMouseleave?: ((_e: MouseEvent) => any) | undefined;
+    onBoxMenuItemClick?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
+    onBoxMenuItemMouseenter?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
+    onBoxMenuItemMouseleave?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
+    onBoxMouseenter?: ((_e: MouseEvent) => any) | undefined;
+    onBoxMouseleave?: ((_e: MouseEvent) => any) | undefined;
+    onSideMenuOpen?: ((_index: string, _indexPath: string[]) => any) | undefined;
+    onSideMenuClose?: ((_index: string, _indexPath: string[]) => any) | undefined;
+    onSideMenuItemClick?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
+    onSideMouseenter?: ((_e: MouseEvent) => any) | undefined;
+    onSideMouseleave?: ((_e: MouseEvent) => any) | undefined;
+    onContentMounted?: ((_contentEl: HTMLElement, _modalsEl: HTMLElement) => any) | undefined;
+}, {
+    height: string | number;
+    collapse: boolean;
+    compact: boolean;
+    tabStyle: import('./types').TabStyle;
+    fixedHeader: boolean;
+    fixedSidebar: boolean;
+    fixedBody: boolean;
+    logoInHeader: boolean;
+    fixedHome: boolean;
+    isHome: boolean;
+    tabSortable: boolean;
+    headerTitleSlot: string;
+    headerIconSlot: string;
+    sidebarTitleSlot: string;
+    sidebarIconSlot: string;
+    sideboxTitleSlot: string;
+    sideboxIconSlot: string;
+    menuScrollToActive: boolean;
+    mobile: boolean;
+}, {}>;
+export default _default;