@vervedoc/ppt 1.0.2

package/dist/views/Editor/Canvas/EditableElement.vue.d.ts

@@ -0,0 +1,1184 @@
+import { PropType } from 'vue';
+import { PPTElement } from '../../../types/slides';
+import { ContextmenuItem } from '../../../components/Contextmenu/types';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    elementInfo: {
+        type: PropType<PPTElement>;
+        required: true;
+    };
+    elementIndex: {
+        type: NumberConstructor;
+        required: true;
+    };
+    isMultiSelect: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    selectElement: {
+        type: PropType<(e: MouseEvent, element: PPTElement, canMove?: boolean) => void>;
+        required: true;
+    };
+    openLinkDialog: {
+        type: PropType<() => void>;
+        required: true;
+    };
+}>, {
+    currentElementComponent: import('vue').ComputedRef<import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        elementInfo: {
+            type: PropType<import('../../../types/slides').PPTImageElement>;
+            required: true;
+        };
+        selectElement: {
+            type: PropType<(e: MouseEvent, element: import('../../../types/slides').PPTImageElement, canMove?: boolean) => void>;
+            required: true;
+        };
+        contextmenus: {
+            type: PropType<() => ContextmenuItem[]>;
+        };
+    }>, {
+        isCliping: import('vue').ComputedRef<boolean>;
+        handleClip: (data: import('../../../types/edit').ImageClipedEmitData) => void;
+        clipingImageElementId: import('vue').Ref<string, string>;
+        shadowStyle: import('vue').ComputedRef<string>;
+        handleSelectElement: (e: MouseEvent) => void;
+        clipShape: import('vue').ComputedRef<any>;
+        imgPosition: import('vue').ComputedRef<{
+            top: string;
+            left: string;
+            width: string;
+            height: string;
+        }>;
+        filter: import('vue').ComputedRef<string>;
+        flipStyle: import('vue').ComputedRef<string>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        elementInfo: {
+            type: PropType<import('../../../types/slides').PPTImageElement>;
+            required: true;
+        };
+        selectElement: {
+            type: PropType<(e: MouseEvent, element: import('../../../types/slides').PPTImageElement, canMove?: boolean) => void>;
+            required: true;
+        };
+        contextmenus: {
+            type: PropType<() => ContextmenuItem[]>;
+        };
+    }>> & Readonly<{}>, {}, {}, {
+        ImageOutline: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            elementInfo: {
+                type: PropType<import('../../../types/slides').PPTImageElement>;
+                required: true;
+            };
+        }>, {
+            clipShape: import('vue').ComputedRef<any>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            elementInfo: {
+                type: PropType<import('../../../types/slides').PPTImageElement>;
+                required: true;
+            };
+        }>> & Readonly<{}>, {}, {}, {
+            ImageRectOutline: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                width: {
+                    type: NumberConstructor;
+                    required: true;
+                };
+                height: {
+                    type: NumberConstructor;
+                    required: true;
+                };
+                outline: {
+                    type: PropType<import('../../../types/slides').PPTElementOutline>;
+                };
+                radius: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>, {
+                outlineWidth: import('vue').ComputedRef<number>;
+                outlineStyle: import('vue').ComputedRef<"dashed" | "solid">;
+                outlineColor: import('vue').ComputedRef<string>;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                width: {
+                    type: NumberConstructor;
+                    required: true;
+                };
+                height: {
+                    type: NumberConstructor;
+                    required: true;
+                };
+                outline: {
+                    type: PropType<import('../../../types/slides').PPTElementOutline>;
+                };
+                radius: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>> & Readonly<{}>, {
+                radius: string;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            ImageEllipseOutline: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                width: {
+                    type: NumberConstructor;
+                    required: true;
+                };
+                height: {
+                    type: NumberConstructor;
+                    required: true;
+                };
+                outline: {
+                    type: PropType<import('../../../types/slides').PPTElementOutline>;
+                };
+            }>, {
+                outlineWidth: import('vue').ComputedRef<number>;
+                outlineStyle: import('vue').ComputedRef<"dashed" | "solid">;
+                outlineColor: import('vue').ComputedRef<string>;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                width: {
+                    type: NumberConstructor;
+                    required: true;
+                };
+                height: {
+                    type: NumberConstructor;
+                    required: true;
+                };
+                outline: {
+                    type: PropType<import('../../../types/slides').PPTElementOutline>;
+                };
+            }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            ImagePolygonOutline: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                width: {
+                    type: NumberConstructor;
+                    required: true;
+                };
+                height: {
+                    type: NumberConstructor;
+                    required: true;
+                };
+                outline: {
+                    type: PropType<import('../../../types/slides').PPTElementOutline>;
+                };
+                createPath: {
+                    type: FunctionConstructor;
+                    required: true;
+                };
+            }>, {
+                outlineWidth: import('vue').ComputedRef<number>;
+                outlineStyle: import('vue').ComputedRef<"dashed" | "solid">;
+                outlineColor: import('vue').ComputedRef<string>;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                width: {
+                    type: NumberConstructor;
+                    required: true;
+                };
+                height: {
+                    type: NumberConstructor;
+                    required: true;
+                };
+                outline: {
+                    type: PropType<import('../../../types/slides').PPTElementOutline>;
+                };
+                createPath: {
+                    type: FunctionConstructor;
+                    required: true;
+                };
+            }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        ImageClipHandler: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            src: {
+                type: StringConstructor;
+                required: true;
+            };
+            clipData: {
+                type: PropType<import('../../../types/edit').ImageClipData>;
+            };
+            clipPath: {
+                type: StringConstructor;
+                required: true;
+            };
+            width: {
+                type: NumberConstructor;
+                required: true;
+            };
+            height: {
+                type: NumberConstructor;
+                required: true;
+            };
+            top: {
+                type: NumberConstructor;
+                required: true;
+            };
+            left: {
+                type: NumberConstructor;
+                required: true;
+            };
+            rotate: {
+                type: NumberConstructor;
+                required: true;
+            };
+        }>, {
+            clipWrapperPositionStyle: import('vue').Ref<{
+                top: string;
+                left: string;
+            }, {
+                top: string;
+                left: string;
+            } | {
+                top: string;
+                left: string;
+            }>;
+            bottomImgPositionStyle: import('vue').ComputedRef<{
+                top: string;
+                left: string;
+                width: string;
+                height: string;
+            }>;
+            topImgWrapperPositionStyle: import('vue').ComputedRef<{
+                top: string;
+                left: string;
+                width: string;
+                height: string;
+            }>;
+            topImgPositionStyle: import('vue').ComputedRef<{
+                left: string;
+                top: string;
+                width: string;
+                height: string;
+            }>;
+            rotateClassName: import('vue').ComputedRef<string>;
+            handleClip: () => void;
+            moveClipRange: (e: MouseEvent) => void;
+            scaleClipRange: (e: MouseEvent, type: import('../../../types/edit').OperateResizeHandlers) => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "clip"[], "clip", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            src: {
+                type: StringConstructor;
+                required: true;
+            };
+            clipData: {
+                type: PropType<import('../../../types/edit').ImageClipData>;
+            };
+            clipPath: {
+                type: StringConstructor;
+                required: true;
+            };
+            width: {
+                type: NumberConstructor;
+                required: true;
+            };
+            height: {
+                type: NumberConstructor;
+                required: true;
+            };
+            top: {
+                type: NumberConstructor;
+                required: true;
+            };
+            left: {
+                type: NumberConstructor;
+                required: true;
+            };
+            rotate: {
+                type: NumberConstructor;
+                required: true;
+            };
+        }>> & Readonly<{
+            onClip?: ((...args: any[]) => any) | undefined;
+        }>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any> | import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        elementInfo: {
+            type: PropType<import('../../../types/slides').PPTTextElement>;
+            required: true;
+        };
+        selectElement: {
+            type: PropType<(e: MouseEvent, element: import('../../../types/slides').PPTTextElement, canMove?: boolean) => void>;
+            required: true;
+        };
+        contextmenus: {
+            type: PropType<() => ContextmenuItem[]>;
+        };
+    }>, {
+        elementRef: import('vue').Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        shadowStyle: import('vue').ComputedRef<string>;
+        textInsetsPadding: import('vue').ComputedRef<string>;
+        updateContent: (content: string) => void;
+        handleSelectElement: (e: MouseEvent, canMove?: boolean) => void;
+        checkEmptyText: () => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        elementInfo: {
+            type: PropType<import('../../../types/slides').PPTTextElement>;
+            required: true;
+        };
+        selectElement: {
+            type: PropType<(e: MouseEvent, element: import('../../../types/slides').PPTTextElement, canMove?: boolean) => void>;
+            required: true;
+        };
+        contextmenus: {
+            type: PropType<() => ContextmenuItem[]>;
+        };
+    }>> & Readonly<{}>, {}, {}, {
+        ElementOutline: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            width: {
+                type: NumberConstructor;
+                required: true;
+            };
+            height: {
+                type: NumberConstructor;
+                required: true;
+            };
+            outline: {
+                type: PropType<import('../../../types/slides').PPTElementOutline>;
+            };
+        }>, {
+            outlineWidth: import('vue').ComputedRef<number>;
+            outlineStyle: import('vue').ComputedRef<"dashed" | "solid">;
+            outlineColor: import('vue').ComputedRef<string>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            width: {
+                type: NumberConstructor;
+                required: true;
+            };
+            height: {
+                type: NumberConstructor;
+                required: true;
+            };
+            outline: {
+                type: PropType<import('../../../types/slides').PPTElementOutline>;
+            };
+        }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        ProsemirrorEditor: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            elementId: {
+                type: StringConstructor;
+                required: true;
+            };
+            defaultColor: {
+                type: StringConstructor;
+                required: true;
+            };
+            defaultFontName: {
+                type: StringConstructor;
+                required: true;
+            };
+            editable: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            value: {
+                type: StringConstructor;
+                required: true;
+            };
+            autoFocus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, {
+            editorViewRef: import('vue').Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("blur" | "focus" | "update")[], "blur" | "focus" | "update", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            elementId: {
+                type: StringConstructor;
+                required: true;
+            };
+            defaultColor: {
+                type: StringConstructor;
+                required: true;
+            };
+            defaultFontName: {
+                type: StringConstructor;
+                required: true;
+            };
+            editable: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            value: {
+                type: StringConstructor;
+                required: true;
+            };
+            autoFocus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{
+            onFocus?: ((...args: any[]) => any) | undefined;
+            onBlur?: ((...args: any[]) => any) | undefined;
+            onUpdate?: ((...args: any[]) => any) | undefined;
+        }>, {
+            editable: boolean;
+            autoFocus: boolean;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any> | import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        elementInfo: {
+            type: PropType<import('../../../types/slides').PPTShapeElement>;
+            required: true;
+        };
+        selectElement: {
+            type: PropType<(e: MouseEvent, element: import('../../../types/slides').PPTShapeElement, canMove?: boolean) => void>;
+            required: true;
+        };
+        contextmenus: {
+            type: PropType<() => ContextmenuItem[]>;
+        };
+    }>, {
+        shadowStyle: import('vue').ComputedRef<string>;
+        outlineWidth: import('vue').ComputedRef<number>;
+        outlineStyle: import('vue').ComputedRef<"dashed" | "solid">;
+        outlineColor: import('vue').ComputedRef<string>;
+        flipStyle: import('vue').ComputedRef<string>;
+        editable: import('vue').Ref<boolean, boolean>;
+        text: import('vue').ComputedRef<import('../../../types/slides').ShapeText>;
+        textInsetsPadding: import('vue').ComputedRef<string>;
+        handleSelectElement: (e: MouseEvent, canMove?: boolean) => void;
+        updateText: (content: string) => void;
+        checkEmptyText: () => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        elementInfo: {
+            type: PropType<import('../../../types/slides').PPTShapeElement>;
+            required: true;
+        };
+        selectElement: {
+            type: PropType<(e: MouseEvent, element: import('../../../types/slides').PPTShapeElement, canMove?: boolean) => void>;
+            required: true;
+        };
+        contextmenus: {
+            type: PropType<() => ContextmenuItem[]>;
+        };
+    }>> & Readonly<{}>, {}, {}, {
+        GradientDefs: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            id: {
+                type: StringConstructor;
+                required: true;
+            };
+            type: {
+                type: PropType<"linear" | "radial">;
+            };
+            color1: {
+                type: StringConstructor;
+                required: true;
+            };
+            color2: {
+                type: StringConstructor;
+                required: true;
+            };
+            rotate: {
+                type: NumberConstructor;
+                default: number;
+            };
+        }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            id: {
+                type: StringConstructor;
+                required: true;
+            };
+            type: {
+                type: PropType<"linear" | "radial">;
+            };
+            color1: {
+                type: StringConstructor;
+                required: true;
+            };
+            color2: {
+                type: StringConstructor;
+                required: true;
+            };
+            rotate: {
+                type: NumberConstructor;
+                default: number;
+            };
+        }>> & Readonly<{}>, {
+            rotate: number;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        ProsemirrorEditor: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            elementId: {
+                type: StringConstructor;
+                required: true;
+            };
+            defaultColor: {
+                type: StringConstructor;
+                required: true;
+            };
+            defaultFontName: {
+                type: StringConstructor;
+                required: true;
+            };
+            editable: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            value: {
+                type: StringConstructor;
+                required: true;
+            };
+            autoFocus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, {
+            editorViewRef: import('vue').Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("blur" | "focus" | "update")[], "blur" | "focus" | "update", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            elementId: {
+                type: StringConstructor;
+                required: true;
+            };
+            defaultColor: {
+                type: StringConstructor;
+                required: true;
+            };
+            defaultFontName: {
+                type: StringConstructor;
+                required: true;
+            };
+            editable: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            value: {
+                type: StringConstructor;
+                required: true;
+            };
+            autoFocus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{
+            onFocus?: ((...args: any[]) => any) | undefined;
+            onBlur?: ((...args: any[]) => any) | undefined;
+            onUpdate?: ((...args: any[]) => any) | undefined;
+        }>, {
+            editable: boolean;
+            autoFocus: boolean;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any> | import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        elementInfo: {
+            type: PropType<import('../../../types/slides').PPTLineElement>;
+            required: true;
+        };
+        selectElement: {
+            type: PropType<(e: MouseEvent, element: import('../../../types/slides').PPTLineElement, canMove?: boolean) => void>;
+            required: true;
+        };
+        contextmenus: {
+            type: PropType<() => ContextmenuItem[]>;
+        };
+    }>, {
+        handleSelectElement: (e: MouseEvent) => void;
+        shadowStyle: import('vue').ComputedRef<string>;
+        svgWidth: import('vue').ComputedRef<number>;
+        svgHeight: import('vue').ComputedRef<number>;
+        lineDashArray: import('vue').ComputedRef<"10 6" | "0 0">;
+        path: import('vue').ComputedRef<string>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        elementInfo: {
+            type: PropType<import('../../../types/slides').PPTLineElement>;
+            required: true;
+        };
+        selectElement: {
+            type: PropType<(e: MouseEvent, element: import('../../../types/slides').PPTLineElement, canMove?: boolean) => void>;
+            required: true;
+        };
+        contextmenus: {
+            type: PropType<() => ContextmenuItem[]>;
+        };
+    }>> & Readonly<{}>, {}, {}, {
+        LinePointMarker: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            id: {
+                type: StringConstructor;
+                required: true;
+            };
+            position: {
+                type: PropType<"start" | "end">;
+                required: true;
+            };
+            type: {
+                type: PropType<"dot" | "arrow">;
+                required: true;
+            };
+            color: {
+                type: StringConstructor;
+            };
+            baseSize: {
+                type: NumberConstructor;
+                required: true;
+            };
+        }>, {
+            path: import('vue').ComputedRef<string>;
+            rotate: import('vue').ComputedRef<number>;
+            size: import('vue').ComputedRef<number>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            id: {
+                type: StringConstructor;
+                required: true;
+            };
+            position: {
+                type: PropType<"start" | "end">;
+                required: true;
+            };
+            type: {
+                type: PropType<"dot" | "arrow">;
+                required: true;
+            };
+            color: {
+                type: StringConstructor;
+            };
+            baseSize: {
+                type: NumberConstructor;
+                required: true;
+            };
+        }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any> | import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        elementInfo: {
+            type: PropType<import('../../../types/slides').PPTChartElement>;
+            required: true;
+        };
+        selectElement: {
+            type: PropType<(e: MouseEvent, element: import('../../../types/slides').PPTChartElement, canMove?: boolean) => void>;
+            required: true;
+        };
+        contextmenus: {
+            type: PropType<() => ContextmenuItem[]>;
+        };
+    }>, {
+        handleSelectElement: (e: MouseEvent) => void;
+        openDataEditor: () => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        elementInfo: {
+            type: PropType<import('../../../types/slides').PPTChartElement>;
+            required: true;
+        };
+        selectElement: {
+            type: PropType<(e: MouseEvent, element: import('../../../types/slides').PPTChartElement, canMove?: boolean) => void>;
+            required: true;
+        };
+        contextmenus: {
+            type: PropType<() => ContextmenuItem[]>;
+        };
+    }>> & Readonly<{}>, {}, {}, {
+        ElementOutline: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            width: {
+                type: NumberConstructor;
+                required: true;
+            };
+            height: {
+                type: NumberConstructor;
+                required: true;
+            };
+            outline: {
+                type: PropType<import('../../../types/slides').PPTElementOutline>;
+            };
+        }>, {
+            outlineWidth: import('vue').ComputedRef<number>;
+            outlineStyle: import('vue').ComputedRef<"dashed" | "solid">;
+            outlineColor: import('vue').ComputedRef<string>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            width: {
+                type: NumberConstructor;
+                required: true;
+            };
+            height: {
+                type: NumberConstructor;
+                required: true;
+            };
+            outline: {
+                type: PropType<import('../../../types/slides').PPTElementOutline>;
+            };
+        }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        Chart: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            width: {
+                type: NumberConstructor;
+                required: true;
+            };
+            height: {
+                type: NumberConstructor;
+                required: true;
+            };
+            type: {
+                type: PropType<import('../../../types/slides').ChartType>;
+                required: true;
+            };
+            data: {
+                type: PropType<import('../../../types/slides').ChartData>;
+                required: true;
+            };
+            options: {
+                type: PropType<import('../../../types/slides').ChartOptions>;
+            };
+            themeColor: {
+                type: PropType<string[]>;
+                required: true;
+            };
+            legends: {
+                type: PropType<string[]>;
+                required: true;
+            };
+            gridColor: {
+                type: StringConstructor;
+            };
+            legend: {
+                type: PropType<"" | "top" | "bottom">;
+            };
+        }>, {
+            chartHeight: import('vue').ComputedRef<number>;
+            themeColors: import('vue').ComputedRef<string[]>;
+            slideScale: import('vue').Ref<number, number>;
+            chartRef: import('vue').Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            width: {
+                type: NumberConstructor;
+                required: true;
+            };
+            height: {
+                type: NumberConstructor;
+                required: true;
+            };
+            type: {
+                type: PropType<import('../../../types/slides').ChartType>;
+                required: true;
+            };
+            data: {
+                type: PropType<import('../../../types/slides').ChartData>;
+                required: true;
+            };
+            options: {
+                type: PropType<import('../../../types/slides').ChartOptions>;
+            };
+            themeColor: {
+                type: PropType<string[]>;
+                required: true;
+            };
+            legends: {
+                type: PropType<string[]>;
+                required: true;
+            };
+            gridColor: {
+                type: StringConstructor;
+            };
+            legend: {
+                type: PropType<"" | "top" | "bottom">;
+            };
+        }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any> | import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        elementInfo: {
+            type: PropType<import('../../../types/slides').PPTTableElement>;
+            required: true;
+        };
+        selectElement: {
+            type: PropType<(e: MouseEvent, element: import('../../../types/slides').PPTTableElement, canMove?: boolean) => void>;
+            required: true;
+        };
+        contextmenus: {
+            type: PropType<() => ContextmenuItem[]>;
+        };
+    }>, {
+        elementRef: import('vue').Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        canvasScale: import('vue').Ref<number, number>;
+        handleSelectElement: (e: MouseEvent) => void;
+        updateTableCells: (data: import('../../../types/slides').TableCell[][]) => void;
+        updateColWidths: (widths: number[]) => void;
+        editable: import('vue').Ref<boolean, boolean>;
+        startEdit: () => void;
+        updateSelectedCells: (cells: string[]) => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        elementInfo: {
+            type: PropType<import('../../../types/slides').PPTTableElement>;
+            required: true;
+        };
+        selectElement: {
+            type: PropType<(e: MouseEvent, element: import('../../../types/slides').PPTTableElement, canMove?: boolean) => void>;
+            required: true;
+        };
+        contextmenus: {
+            type: PropType<() => ContextmenuItem[]>;
+        };
+    }>> & Readonly<{}>, {}, {}, {
+        EditableTable: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            data: {
+                type: PropType<import('../../../types/slides').TableCell[][]>;
+                required: true;
+            };
+            width: {
+                type: NumberConstructor;
+                required: true;
+            };
+            colWidths: {
+                type: PropType<number[]>;
+                required: true;
+            };
+            outline: {
+                type: PropType<import('../../../types/slides').PPTElementOutline>;
+                required: true;
+            };
+            theme: {
+                type: PropType<import('../../../types/slides').TableTheme>;
+            };
+            editable: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, {
+            getTextStyle: (style?: import('../../../types/slides').TableCellStyle) => {
+                fontWeight?: undefined;
+                fontStyle?: undefined;
+                textDecoration?: undefined;
+                color?: undefined;
+                backgroundColor?: undefined;
+                fontSize?: undefined;
+                fontFamily?: undefined;
+                textAlign?: undefined;
+            } | {
+                fontWeight: string;
+                fontStyle: string;
+                textDecoration: string;
+                color: string;
+                backgroundColor: string;
+                fontSize: string;
+                fontFamily: string;
+                textAlign: "left" | "center" | "right";
+            };
+            dragLinePosition: import('vue').ComputedRef<number[]>;
+            tableCells: import('vue').WritableComputedRef<import('../../../types/slides').TableCell[][], import('../../../types/slides').TableCell[][]>;
+            colSizeList: import('vue').Ref<number[], number[]>;
+            totalWidth: import('vue').ComputedRef<number>;
+            hideCells: import('vue').ComputedRef<string[]>;
+            selectedCells: import('vue').ComputedRef<string[]>;
+            activedCell: import('vue').ComputedRef<string | null>;
+            selectedRange: import('vue').ComputedRef<{
+                row: number[];
+                col: number[];
+            } | null>;
+            handleCellMousedown: (e: MouseEvent, rowIndex: number, colIndex: number) => void;
+            handleCellMouseenter: (rowIndex: number, colIndex: number) => void;
+            selectCol: (index: number) => void;
+            selectRow: (index: number) => void;
+            handleMousedownColHandler: (e: MouseEvent, colIndex: number) => void;
+            contextmenus: (el: HTMLElement) => ContextmenuItem[];
+            handleInput: import('lodash').DebouncedFunc<(value: any, rowIndex: any, colIndex: any) => void>;
+            insertExcelData: (data: string[][], rowIndex: number, colIndex: number) => void;
+            subThemeColor: import('vue').Ref<string[], string[]>;
+            formatText: (text: string) => string;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("change" | "changeColWidths" | "changeSelectedCells")[], "change" | "changeColWidths" | "changeSelectedCells", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            data: {
+                type: PropType<import('../../../types/slides').TableCell[][]>;
+                required: true;
+            };
+            width: {
+                type: NumberConstructor;
+                required: true;
+            };
+            colWidths: {
+                type: PropType<number[]>;
+                required: true;
+            };
+            outline: {
+                type: PropType<import('../../../types/slides').PPTElementOutline>;
+                required: true;
+            };
+            theme: {
+                type: PropType<import('../../../types/slides').TableTheme>;
+            };
+            editable: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{
+            onChange?: ((...args: any[]) => any) | undefined;
+            onChangeColWidths?: ((...args: any[]) => any) | undefined;
+            onChangeSelectedCells?: ((...args: any[]) => any) | undefined;
+        }>, {
+            editable: boolean;
+        }, {}, {
+            CustomTextarea: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                value: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                contenteditable: {
+                    type: (BooleanConstructor | StringConstructor)[];
+                    default: boolean;
+                };
+            }>, {
+                textareaRef: import('vue').Ref<HTMLElement | undefined, HTMLElement | undefined>;
+                handleFocus: () => void;
+                handleInput: () => void;
+                handleBlur: () => void;
+                text: import('vue').Ref<string, string>;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("updateValue" | "insertExcelData")[], "updateValue" | "insertExcelData", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                value: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                contenteditable: {
+                    type: (BooleanConstructor | StringConstructor)[];
+                    default: boolean;
+                };
+            }>> & Readonly<{
+                onUpdateValue?: ((...args: any[]) => any) | undefined;
+                onInsertExcelData?: ((...args: any[]) => any) | undefined;
+            }>, {
+                value: string;
+                contenteditable: string | boolean;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any> | import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        elementInfo: {
+            type: PropType<import('../../../types/slides').PPTLatexElement>;
+            required: true;
+        };
+        selectElement: {
+            type: PropType<(e: MouseEvent, element: import('../../../types/slides').PPTLatexElement, canMove?: boolean) => void>;
+            required: true;
+        };
+        contextmenus: {
+            type: PropType<() => ContextmenuItem[]>;
+        };
+    }>, {
+        handleSelectElement: (e: MouseEvent) => void;
+        openLatexEditor: () => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        elementInfo: {
+            type: PropType<import('../../../types/slides').PPTLatexElement>;
+            required: true;
+        };
+        selectElement: {
+            type: PropType<(e: MouseEvent, element: import('../../../types/slides').PPTLatexElement, canMove?: boolean) => void>;
+            required: true;
+        };
+        contextmenus: {
+            type: PropType<() => ContextmenuItem[]>;
+        };
+    }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any> | import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        elementInfo: {
+            type: PropType<import('../../../types/slides').PPTVideoElement>;
+            required: true;
+        };
+        selectElement: {
+            type: PropType<(e: MouseEvent, element: import('../../../types/slides').PPTVideoElement, canMove?: boolean) => void>;
+            required: true;
+        };
+        contextmenus: {
+            type: PropType<() => ContextmenuItem[]>;
+        };
+    }>, {
+        canvasScale: import('vue').Ref<number, number>;
+        handleSelectElement: (e: MouseEvent, canMove?: boolean) => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        elementInfo: {
+            type: PropType<import('../../../types/slides').PPTVideoElement>;
+            required: true;
+        };
+        selectElement: {
+            type: PropType<(e: MouseEvent, element: import('../../../types/slides').PPTVideoElement, canMove?: boolean) => void>;
+            required: true;
+        };
+        contextmenus: {
+            type: PropType<() => ContextmenuItem[]>;
+        };
+    }>> & Readonly<{}>, {}, {}, {
+        VideoPlayer: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            width: {
+                type: NumberConstructor;
+                required: true;
+            };
+            height: {
+                type: NumberConstructor;
+                required: true;
+            };
+            src: {
+                type: StringConstructor;
+                required: true;
+            };
+            poster: {
+                type: StringConstructor;
+                default: string;
+            };
+            scale: {
+                type: NumberConstructor;
+                default: number;
+            };
+        }>, {
+            videoRef: import('vue').Ref<HTMLVideoElement | undefined, HTMLVideoElement | undefined>;
+            playBarWrap: import('vue').Ref<HTMLElement | undefined, HTMLElement | undefined>;
+            volumeBarRef: import('vue').Ref<HTMLElement | undefined, HTMLElement | undefined>;
+            volume: import('vue').Ref<number, number>;
+            loop: import('vue').Ref<boolean, boolean>;
+            paused: import('vue').Ref<boolean, boolean>;
+            ptime: import('vue').ComputedRef<string>;
+            dtime: import('vue').ComputedRef<string>;
+            playBarTime: import('vue').Ref<string, string>;
+            playBarTimeVisible: import('vue').Ref<boolean, boolean>;
+            playBarTimeLeft: import('vue').Ref<string, string>;
+            playedBarWidth: import('vue').ComputedRef<string>;
+            loadedBarWidth: import('vue').ComputedRef<string>;
+            volumeBarWidth: import('vue').ComputedRef<string>;
+            hideController: import('vue').Ref<boolean, boolean>;
+            bezelTransition: import('vue').Ref<boolean, boolean>;
+            playbackRate: import('vue').Ref<number, number>;
+            speedMenuVisible: import('vue').Ref<boolean, boolean>;
+            speedOptions: {
+                label: string;
+                value: number;
+            }[];
+            seek: (time: number) => void;
+            play: () => void;
+            pause: () => void;
+            toggle: () => void;
+            setVolume: (percentage: number) => void;
+            speed: (rate: number) => void;
+            handleDurationchange: () => void;
+            handleTimeupdate: () => void;
+            handleEnded: () => void;
+            handleProgress: () => void;
+            handleMousedownPlayBar: () => void;
+            handleMousedownVolumeBar: () => void;
+            handleClickVolumeBar: (e: MouseEvent) => void;
+            handleMousemovePlayBar: (e: MouseEvent) => void;
+            toggleVolume: () => void;
+            toggleLoop: () => void;
+            autoHideController: () => void;
+            handleError: () => import('element-plus').MessageHandler;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            width: {
+                type: NumberConstructor;
+                required: true;
+            };
+            height: {
+                type: NumberConstructor;
+                required: true;
+            };
+            src: {
+                type: StringConstructor;
+                required: true;
+            };
+            poster: {
+                type: StringConstructor;
+                default: string;
+            };
+            scale: {
+                type: NumberConstructor;
+                default: number;
+            };
+        }>> & Readonly<{}>, {
+            poster: string;
+            scale: number;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any> | import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        elementInfo: {
+            type: PropType<import('../../../types/slides').PPTAudioElement>;
+            required: true;
+        };
+        selectElement: {
+            type: PropType<(e: MouseEvent, element: import('../../../types/slides').PPTAudioElement, canMove?: boolean) => void>;
+            required: true;
+        };
+        contextmenus: {
+            type: PropType<() => ContextmenuItem[]>;
+        };
+    }>, {
+        canvasScale: import('vue').Ref<number, number>;
+        handleElementId: import('vue').Ref<string, string>;
+        audioIconSize: import('vue').ComputedRef<string>;
+        audioPlayerPosition: import('vue').ComputedRef<{
+            left: string;
+            top: string;
+        }>;
+        handleSelectElement: (e: MouseEvent) => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        elementInfo: {
+            type: PropType<import('../../../types/slides').PPTAudioElement>;
+            required: true;
+        };
+        selectElement: {
+            type: PropType<(e: MouseEvent, element: import('../../../types/slides').PPTAudioElement, canMove?: boolean) => void>;
+            required: true;
+        };
+        contextmenus: {
+            type: PropType<() => ContextmenuItem[]>;
+        };
+    }>> & Readonly<{}>, {}, {}, {
+        AudioPlayer: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            src: {
+                type: StringConstructor;
+                required: true;
+            };
+            loop: {
+                type: BooleanConstructor;
+                required: true;
+            };
+            autoplay: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            scale: {
+                type: NumberConstructor;
+                default: number;
+            };
+        }>, {
+            audioRef: import('vue').Ref<HTMLAudioElement | undefined, HTMLAudioElement | undefined>;
+            playBarWrap: import('vue').Ref<HTMLElement | undefined, HTMLElement | undefined>;
+            volumeBarRef: import('vue').Ref<HTMLElement | undefined, HTMLElement | undefined>;
+            volume: import('vue').Ref<number, number>;
+            paused: import('vue').Ref<boolean, boolean>;
+            ptime: import('vue').ComputedRef<string>;
+            dtime: import('vue').ComputedRef<string>;
+            playBarTime: import('vue').Ref<string, string>;
+            playBarTimeVisible: import('vue').Ref<boolean, boolean>;
+            playBarTimeLeft: import('vue').Ref<string, string>;
+            playedBarWidth: import('vue').ComputedRef<string>;
+            loadedBarWidth: import('vue').ComputedRef<string>;
+            volumeBarWidth: import('vue').ComputedRef<string>;
+            play: () => void;
+            pause: () => void;
+            toggle: () => void;
+            setVolume: (percentage: number) => void;
+            handleDurationchange: () => void;
+            handleTimeupdate: () => void;
+            handlePlayed: () => void;
+            handleEnded: () => void;
+            handleProgress: () => void;
+            handleError: () => import('element-plus').MessageHandler;
+            handleMousedownPlayBar: () => void;
+            handleMousedownVolumeBar: () => void;
+            handleClickVolumeBar: (e: MouseEvent) => void;
+            handleMousemovePlayBar: (e: MouseEvent) => void;
+            toggleVolume: () => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            src: {
+                type: StringConstructor;
+                required: true;
+            };
+            loop: {
+                type: BooleanConstructor;
+                required: true;
+            };
+            autoplay: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            scale: {
+                type: NumberConstructor;
+                default: number;
+            };
+        }>> & Readonly<{}>, {
+            autoplay: boolean;
+            scale: number;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>>;
+    contextmenus: () => ContextmenuItem[];
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    elementInfo: {
+        type: PropType<PPTElement>;
+        required: true;
+    };
+    elementIndex: {
+        type: NumberConstructor;
+        required: true;
+    };
+    isMultiSelect: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    selectElement: {
+        type: PropType<(e: MouseEvent, element: PPTElement, canMove?: boolean) => void>;
+        required: true;
+    };
+    openLinkDialog: {
+        type: PropType<() => void>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=EditableElement.vue.d.ts.map