element-less 0.0.1 → 0.0.3

package/custom/mdPreview/index.d.ts

@@ -0,0 +1,10 @@
+export declare const ElsMdPreview: import('element-plus/es/utils/index').SFCWithInstall<import('vue').DefineComponent<{
+    modelValue: {
+        type: import('vue').PropType<string>;
+    };
+}, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    modelValue: {
+        type: import('vue').PropType<string>;
+    };
+}>>, {}, {}>> & Record<string, any>;
+export default ElsMdPreview;

package/custom/mdPreview/src/mdPreview.vue.d.ts

@@ -0,0 +1,14 @@
+interface Props {
+    modelValue?: string;
+}
+declare const _default: import('vue').DefineComponent<__VLS_TypePropsToOption<Props>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<Props>>>, {}, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/custom/menu-context/index.d.ts

@@ -0,0 +1,46 @@
+export declare const ElsMenuContext: import('element-plus/es/utils/index').SFCWithInstall<import('vue').DefineComponent<{
+    data: import('element-plus/es/utils/index').EpPropFinalized<{
+        (arrayLength: number): Record<string, any>[];
+        (...items: Record<string, any>[]): Record<string, any>[];
+        new (arrayLength: number): Record<string, any>[];
+        new (...items: Record<string, any>[]): Record<string, any>[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        readonly [Symbol.species]: ArrayConstructor;
+    }, unknown, unknown, never[], boolean>;
+    positionLeft: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    positionTop: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    visible: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    onClick: FunctionConstructor;
+}, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    data: import('element-plus/es/utils/index').EpPropFinalized<{
+        (arrayLength: number): Record<string, any>[];
+        (...items: Record<string, any>[]): Record<string, any>[];
+        new (arrayLength: number): Record<string, any>[];
+        new (...items: Record<string, any>[]): Record<string, any>[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        readonly [Symbol.species]: ArrayConstructor;
+    }, unknown, unknown, never[], boolean>;
+    positionLeft: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    positionTop: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    visible: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    onClick: FunctionConstructor;
+}>>, {
+    data: Record<string, any>[];
+    visible: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    positionLeft: number;
+    positionTop: number;
+}, {}>> & Record<string, any>;
+export default ElsMenuContext;
+export * from './src/menuContext';

package/custom/menu-context/src/menuContext.d.ts

@@ -0,0 +1,24 @@
+import { ExtractPropTypes } from 'vue';
+import { default as MenuContext } from './menuContext.vue';
+export declare const menuContextProps: {
+    data: import('element-plus/es/utils/index').EpPropFinalized<{
+        (arrayLength: number): Record<string, any>[];
+        (...items: Record<string, any>[]): Record<string, any>[];
+        new (arrayLength: number): Record<string, any>[];
+        new (...items: Record<string, any>[]): Record<string, any>[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        readonly [Symbol.species]: ArrayConstructor;
+    }, unknown, unknown, never[], boolean>;
+    positionLeft: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    positionTop: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    visible: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    onClick: FunctionConstructor;
+};
+export type MenuContextProps = ExtractPropTypes<typeof menuContextProps>;
+export type MenuContextInstance = InstanceType<typeof MenuContext>;

package/custom/menu-context/src/menuContext.vue.d.ts

@@ -0,0 +1,45 @@
+declare const _default: import('vue').DefineComponent<{
+    data: import('element-plus/es/utils/index.mjs').EpPropFinalized<{
+        (arrayLength: number): Record<string, any>[];
+        (...items: Record<string, any>[]): Record<string, any>[];
+        new (arrayLength: number): Record<string, any>[];
+        new (...items: Record<string, any>[]): Record<string, any>[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        readonly [Symbol.species]: ArrayConstructor;
+    }, unknown, unknown, never[], boolean>;
+    positionLeft: import('element-plus/es/utils/index.mjs').EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    positionTop: import('element-plus/es/utils/index.mjs').EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    visible: import('element-plus/es/utils/index.mjs').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    onClick: FunctionConstructor;
+}, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    data: import('element-plus/es/utils/index.mjs').EpPropFinalized<{
+        (arrayLength: number): Record<string, any>[];
+        (...items: Record<string, any>[]): Record<string, any>[];
+        new (arrayLength: number): Record<string, any>[];
+        new (...items: Record<string, any>[]): Record<string, any>[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        readonly [Symbol.species]: ArrayConstructor;
+    }, unknown, unknown, never[], boolean>;
+    positionLeft: import('element-plus/es/utils/index.mjs').EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    positionTop: import('element-plus/es/utils/index.mjs').EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    visible: import('element-plus/es/utils/index.mjs').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    onClick: FunctionConstructor;
+}>>, {
+    data: Record<string, any>[];
+    visible: import('element-plus/es/utils/index.mjs').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    positionLeft: number;
+    positionTop: number;
+}, {}>;
+export default _default;

package/custom/menu-dropdown/index.d.ts

@@ -0,0 +1,46 @@
+export declare const ElsMenuDropdown: import('element-plus/es/utils/index').SFCWithInstall<import('vue').DefineComponent<{
+    data: import('element-plus/es/utils/index').EpPropFinalized<{
+        (arrayLength: number): Record<string, any>[];
+        (...items: Record<string, any>[]): Record<string, any>[];
+        new (arrayLength: number): Record<string, any>[];
+        new (...items: Record<string, any>[]): Record<string, any>[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        readonly [Symbol.species]: ArrayConstructor;
+    }, unknown, unknown, never[], boolean>;
+    isFold: BooleanConstructor;
+    unFoldCount: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    isMobile: BooleanConstructor;
+    onClick: FunctionConstructor;
+}, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    data: import('element-plus/es/utils/index').EpPropFinalized<{
+        (arrayLength: number): Record<string, any>[];
+        (...items: Record<string, any>[]): Record<string, any>[];
+        new (arrayLength: number): Record<string, any>[];
+        new (...items: Record<string, any>[]): Record<string, any>[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        readonly [Symbol.species]: ArrayConstructor;
+    }, unknown, unknown, never[], boolean>;
+    isFold: BooleanConstructor;
+    unFoldCount: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    isMobile: BooleanConstructor;
+    onClick: FunctionConstructor;
+}>>, {
+    data: Record<string, any>[];
+    isMobile: boolean;
+    isFold: boolean;
+    unFoldCount: number;
+}, {}>> & Record<string, any>;
+export default ElsMenuDropdown;
+export * from './src/menuDropdown';

package/custom/menu-dropdown/src/menuDropdown.d.ts

@@ -0,0 +1,24 @@
+import { ExtractPropTypes } from 'vue';
+import { default as MenuDropdown } from './menuDropdown.vue';
+export declare const menuDropdownProps: {
+    data: import('element-plus/es/utils/index').EpPropFinalized<{
+        (arrayLength: number): Record<string, any>[];
+        (...items: Record<string, any>[]): Record<string, any>[];
+        new (arrayLength: number): Record<string, any>[];
+        new (...items: Record<string, any>[]): Record<string, any>[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        readonly [Symbol.species]: ArrayConstructor;
+    }, unknown, unknown, never[], boolean>;
+    isFold: BooleanConstructor;
+    unFoldCount: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    isMobile: BooleanConstructor;
+    onClick: FunctionConstructor;
+};
+export type MenuDropdownProps = ExtractPropTypes<typeof menuDropdownProps>;
+export type MenuDropdownInstance = InstanceType<typeof MenuDropdown>;

package/custom/menu-dropdown/src/menuDropdown.vue.d.ts

@@ -0,0 +1,45 @@
+declare const _default: import('vue').DefineComponent<{
+    data: import('element-plus/es/utils/index.mjs').EpPropFinalized<{
+        (arrayLength: number): Record<string, any>[];
+        (...items: Record<string, any>[]): Record<string, any>[];
+        new (arrayLength: number): Record<string, any>[];
+        new (...items: Record<string, any>[]): Record<string, any>[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        readonly [Symbol.species]: ArrayConstructor;
+    }, unknown, unknown, never[], boolean>;
+    isFold: BooleanConstructor;
+    unFoldCount: import('element-plus/es/utils/index.mjs').EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    isMobile: BooleanConstructor;
+    onClick: FunctionConstructor;
+}, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    data: import('element-plus/es/utils/index.mjs').EpPropFinalized<{
+        (arrayLength: number): Record<string, any>[];
+        (...items: Record<string, any>[]): Record<string, any>[];
+        new (arrayLength: number): Record<string, any>[];
+        new (...items: Record<string, any>[]): Record<string, any>[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        readonly [Symbol.species]: ArrayConstructor;
+    }, unknown, unknown, never[], boolean>;
+    isFold: BooleanConstructor;
+    unFoldCount: import('element-plus/es/utils/index.mjs').EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    isMobile: BooleanConstructor;
+    onClick: FunctionConstructor;
+}>>, {
+    data: Record<string, any>[];
+    isMobile: boolean;
+    isFold: boolean;
+    unFoldCount: number;
+}, {}>;
+export default _default;

package/custom/menu-tool/index.d.ts

@@ -0,0 +1,134 @@
+export declare const ElsMenuTool: import('element-plus/es/utils/index').SFCWithInstall<{
+    new (...args: any[]): import('vue').CreateComponentPublicInstance<Readonly<import('vue').ExtractPropTypes<{
+        url: StringConstructor;
+        logUrl: StringConstructor;
+        docUrl: StringConstructor;
+        noteUrl: StringConstructor;
+        mutiSaveUrl: StringConstructor;
+        data: import('element-plus/es/utils/index').EpPropFinalized<{
+            (arrayLength: number): Record<string, any>[];
+            (...items: Record<string, any>[]): Record<string, any>[];
+            new (arrayLength: number): Record<string, any>[];
+            new (...items: Record<string, any>[]): Record<string, any>[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            readonly [Symbol.species]: ArrayConstructor;
+        }, unknown, unknown, never[], boolean>;
+        buttonType: StringConstructor;
+        showMenuName: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+        moreCommand: FunctionConstructor;
+        onClick: FunctionConstructor;
+        onUploaded: FunctionConstructor;
+    }>>, {
+        triggerPowerMenu: (menuID: any) => void;
+    }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & Readonly<import('vue').ExtractPropTypes<{
+        url: StringConstructor;
+        logUrl: StringConstructor;
+        docUrl: StringConstructor;
+        noteUrl: StringConstructor;
+        mutiSaveUrl: StringConstructor;
+        data: import('element-plus/es/utils/index').EpPropFinalized<{
+            (arrayLength: number): Record<string, any>[];
+            (...items: Record<string, any>[]): Record<string, any>[];
+            new (arrayLength: number): Record<string, any>[];
+            new (...items: Record<string, any>[]): Record<string, any>[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            readonly [Symbol.species]: ArrayConstructor;
+        }, unknown, unknown, never[], boolean>;
+        buttonType: StringConstructor;
+        showMenuName: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+        moreCommand: FunctionConstructor;
+        onClick: FunctionConstructor;
+        onUploaded: FunctionConstructor;
+    }>>, {
+        data: Record<string, any>[];
+        showMenuName: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    }, true, {}, {}, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('vue').ExtractPropTypes<{
+        url: StringConstructor;
+        logUrl: StringConstructor;
+        docUrl: StringConstructor;
+        noteUrl: StringConstructor;
+        mutiSaveUrl: StringConstructor;
+        data: import('element-plus/es/utils/index').EpPropFinalized<{
+            (arrayLength: number): Record<string, any>[];
+            (...items: Record<string, any>[]): Record<string, any>[];
+            new (arrayLength: number): Record<string, any>[];
+            new (...items: Record<string, any>[]): Record<string, any>[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            readonly [Symbol.species]: ArrayConstructor;
+        }, unknown, unknown, never[], boolean>;
+        buttonType: StringConstructor;
+        showMenuName: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+        moreCommand: FunctionConstructor;
+        onClick: FunctionConstructor;
+        onUploaded: FunctionConstructor;
+    }>>, {
+        triggerPowerMenu: (menuID: any) => void;
+    }, {}, {}, {}, {
+        data: Record<string, any>[];
+        showMenuName: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+    url: StringConstructor;
+    logUrl: StringConstructor;
+    docUrl: StringConstructor;
+    noteUrl: StringConstructor;
+    mutiSaveUrl: StringConstructor;
+    data: import('element-plus/es/utils/index').EpPropFinalized<{
+        (arrayLength: number): Record<string, any>[];
+        (...items: Record<string, any>[]): Record<string, any>[];
+        new (arrayLength: number): Record<string, any>[];
+        new (...items: Record<string, any>[]): Record<string, any>[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        readonly [Symbol.species]: ArrayConstructor;
+    }, unknown, unknown, never[], boolean>;
+    buttonType: StringConstructor;
+    showMenuName: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    moreCommand: FunctionConstructor;
+    onClick: FunctionConstructor;
+    onUploaded: FunctionConstructor;
+}>>, {
+    triggerPowerMenu: (menuID: any) => void;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+    data: Record<string, any>[];
+    showMenuName: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+}, {}, string, {}> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        default?(_: {}): any;
+    };
+})> & Record<string, any>;
+export default ElsMenuTool;
+export * from './src/menuTool';

package/custom/menu-tool/src/menuTool.d.ts

@@ -0,0 +1,30 @@
+import { ExtractPropTypes } from 'vue';
+import { default as MenuTool } from './menuTool.vue';
+export declare const menuToolProps: {
+    url: StringConstructor;
+    logUrl: StringConstructor;
+    docUrl: StringConstructor;
+    noteUrl: StringConstructor;
+    mutiSaveUrl: StringConstructor;
+    data: import('element-plus/es/utils/index').EpPropFinalized<{
+        (arrayLength: number): Record<string, any>[];
+        (...items: Record<string, any>[]): Record<string, any>[];
+        new (arrayLength: number): Record<string, any>[];
+        new (...items: Record<string, any>[]): Record<string, any>[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        readonly [Symbol.species]: ArrayConstructor;
+    }, unknown, unknown, never[], boolean>;
+    buttonType: StringConstructor;
+    showMenuName: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    moreCommand: FunctionConstructor;
+    onClick: FunctionConstructor;
+    onUploaded: FunctionConstructor;
+};
+export type MenuToolProps = ExtractPropTypes<typeof menuToolProps>;
+export type MenuToolInstance = InstanceType<typeof MenuTool>;

package/custom/menu-tool/src/menuTool.vue.d.ts

@@ -0,0 +1,67 @@
+declare function triggerPowerMenu(menuID: any): void;
+declare function __VLS_template(): {
+    default?(_: {}): any;
+};
+declare const __VLS_component: import('vue').DefineComponent<{
+    url: StringConstructor;
+    logUrl: StringConstructor;
+    docUrl: StringConstructor;
+    noteUrl: StringConstructor;
+    mutiSaveUrl: StringConstructor;
+    data: import('element-plus/es/utils/index.mjs').EpPropFinalized<{
+        (arrayLength: number): Record<string, any>[];
+        (...items: Record<string, any>[]): Record<string, any>[];
+        new (arrayLength: number): Record<string, any>[];
+        new (...items: Record<string, any>[]): Record<string, any>[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        readonly [Symbol.species]: ArrayConstructor;
+    }, unknown, unknown, never[], boolean>;
+    buttonType: StringConstructor;
+    showMenuName: import('element-plus/es/utils/index.mjs').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    moreCommand: FunctionConstructor;
+    onClick: FunctionConstructor;
+    onUploaded: FunctionConstructor;
+}, {
+    triggerPowerMenu: typeof triggerPowerMenu;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    url: StringConstructor;
+    logUrl: StringConstructor;
+    docUrl: StringConstructor;
+    noteUrl: StringConstructor;
+    mutiSaveUrl: StringConstructor;
+    data: import('element-plus/es/utils/index.mjs').EpPropFinalized<{
+        (arrayLength: number): Record<string, any>[];
+        (...items: Record<string, any>[]): Record<string, any>[];
+        new (arrayLength: number): Record<string, any>[];
+        new (...items: Record<string, any>[]): Record<string, any>[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        readonly [Symbol.species]: ArrayConstructor;
+    }, unknown, unknown, never[], boolean>;
+    buttonType: StringConstructor;
+    showMenuName: import('element-plus/es/utils/index.mjs').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    moreCommand: FunctionConstructor;
+    onClick: FunctionConstructor;
+    onUploaded: FunctionConstructor;
+}>>, {
+    data: Record<string, any>[];
+    showMenuName: import('element-plus/es/utils/index.mjs').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+}, {}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/custom/stampBadge/index.d.ts

@@ -0,0 +1,110 @@
+export declare const ElsStampBadge: import('element-plus/es/utils/index').SFCWithInstall<{
+    new (...args: any[]): import('vue').CreateComponentPublicInstance<Readonly<import('vue').ExtractPropTypes<{
+        type: {
+            type: import('vue').PropType<string>;
+            required: true;
+            default: string;
+        };
+        size: {
+            type: import('vue').PropType<string>;
+            required: true;
+            default: string;
+        };
+        content: {
+            type: import('vue').PropType<string>;
+            default: string;
+        };
+        rotate: {
+            type: import('vue').PropType<number>;
+            default: number;
+        };
+    }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & Readonly<import('vue').ExtractPropTypes<{
+        type: {
+            type: import('vue').PropType<string>;
+            required: true;
+            default: string;
+        };
+        size: {
+            type: import('vue').PropType<string>;
+            required: true;
+            default: string;
+        };
+        content: {
+            type: import('vue').PropType<string>;
+            default: string;
+        };
+        rotate: {
+            type: import('vue').PropType<number>;
+            default: number;
+        };
+    }>>, {
+        type: string;
+        size: string;
+        content: string;
+        rotate: number;
+    }, true, {}, {}, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('vue').ExtractPropTypes<{
+        type: {
+            type: import('vue').PropType<string>;
+            required: true;
+            default: string;
+        };
+        size: {
+            type: import('vue').PropType<string>;
+            required: true;
+            default: string;
+        };
+        content: {
+            type: import('vue').PropType<string>;
+            default: string;
+        };
+        rotate: {
+            type: import('vue').PropType<number>;
+            default: number;
+        };
+    }>>, {}, {}, {}, {}, {
+        type: string;
+        size: string;
+        content: string;
+        rotate: number;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+    type: {
+        type: import('vue').PropType<string>;
+        required: true;
+        default: string;
+    };
+    size: {
+        type: import('vue').PropType<string>;
+        required: true;
+        default: string;
+    };
+    content: {
+        type: import('vue').PropType<string>;
+        default: string;
+    };
+    rotate: {
+        type: import('vue').PropType<number>;
+        default: number;
+    };
+}>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+    type: string;
+    size: string;
+    content: string;
+    rotate: number;
+}, {}, string, {}> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        default?(_: {}): any;
+    };
+})> & Record<string, any>;
+export default ElsStampBadge;
+export * from './src/stampBadge';

package/custom/stampBadge/src/stampBadge.d.ts

@@ -0,0 +1,15 @@
+import { ExtractPropTypes } from 'vue';
+import { default as StampBadge } from './stampBadge.vue';
+export declare const stampBadgeProps: {
+    type: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, "success" | "warning" | "info" | "default" | "primary" | "danger", unknown, string, boolean>;
+    size: {
+        readonly type: import('vue').PropType<import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    rotate: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    content: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+};
+export type StampBadgeProps = ExtractPropTypes<typeof stampBadgeProps>;
+export type StampBadgeInstance = InstanceType<typeof StampBadge>;