@vervedoc/ppt 1.0.2

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

@@ -0,0 +1,3917 @@
+import { ContextmenuItem } from '../../../components/Contextmenu/types';
+import { PPTElement } from '../../../types/slides';
+import { AlignmentLineProps } from '../../../types/edit';
+declare const _default: import('vue').DefineComponent<{}, {
+    elementList: import('vue').Ref<({
+        type: "text";
+        content: string;
+        defaultFontName: string;
+        defaultColor: string;
+        outline?: {
+            style?: ("dashed" | "solid") | undefined;
+            width?: number | undefined;
+            color?: string | undefined;
+        } | undefined;
+        fill?: string | undefined;
+        lineHeight?: number | undefined;
+        wordSpace?: number | undefined;
+        opacity?: number | undefined;
+        shadow?: {
+            h: number;
+            v: number;
+            blur: number;
+            color: string;
+        } | undefined;
+        textIndent?: number | undefined;
+        paragraphSpace?: number | undefined;
+        textInsets?: [number, number, number, number] | undefined;
+        id: string;
+        left: number;
+        top: number;
+        lock?: boolean | undefined;
+        groupId?: string | undefined;
+        width: number;
+        height: number;
+        rotate: number;
+        link?: {
+            type: "web" | "slide";
+            target: string;
+        } | undefined;
+    } | {
+        type: "image";
+        fixedRatio: boolean;
+        src: string;
+        outline?: {
+            style?: ("dashed" | "solid") | undefined;
+            width?: number | undefined;
+            color?: string | undefined;
+        } | undefined;
+        filters?: {
+            blur?: string | undefined;
+            brightness?: string | undefined;
+            contrast?: string | undefined;
+            grayscale?: string | undefined;
+            saturate?: string | undefined;
+            'hue-rotate'?: string | undefined;
+            opacity?: string | undefined;
+        } | undefined;
+        clip?: {
+            range: [[number, number], [number, number]];
+            shape: string;
+        } | undefined;
+        flipH?: boolean | undefined;
+        flipV?: boolean | undefined;
+        shadow?: {
+            h: number;
+            v: number;
+            blur: number;
+            color: string;
+        } | undefined;
+        id: string;
+        left: number;
+        top: number;
+        lock?: boolean | undefined;
+        groupId?: string | undefined;
+        width: number;
+        height: number;
+        rotate: number;
+        link?: {
+            type: "web" | "slide";
+            target: string;
+        } | undefined;
+    } | {
+        type: "shape";
+        viewBox: [number, number];
+        path: string;
+        fixedRatio: boolean;
+        fill: string;
+        gradient?: {
+            type: "linear" | "radial";
+            color: [string, string];
+            rotate: number;
+        } | undefined;
+        outline?: {
+            style?: ("dashed" | "solid") | undefined;
+            width?: number | undefined;
+            color?: string | undefined;
+        } | undefined;
+        opacity?: number | undefined;
+        flipH?: boolean | undefined;
+        flipV?: boolean | undefined;
+        shadow?: {
+            h: number;
+            v: number;
+            blur: number;
+            color: string;
+        } | undefined;
+        special?: boolean | undefined;
+        text?: {
+            content: string;
+            defaultFontName: string;
+            defaultColor: string;
+            align: "top" | "middle" | "bottom";
+            textInsets?: [number, number, number, number] | undefined;
+        } | undefined;
+        pathFormula?: import('../../../types/slides').ShapePathFormulasKeys | undefined;
+        id: string;
+        left: number;
+        top: number;
+        lock?: boolean | undefined;
+        groupId?: string | undefined;
+        width: number;
+        height: number;
+        rotate: number;
+        link?: {
+            type: "web" | "slide";
+            target: string;
+        } | undefined;
+    } | {
+        type: "line";
+        start: [number, number];
+        end: [number, number];
+        style: "solid" | "dashed";
+        color: string;
+        points: [import('../../../types/slides').LinePoint, import('../../../types/slides').LinePoint];
+        shadow?: {
+            h: number;
+            v: number;
+            blur: number;
+            color: string;
+        } | undefined;
+        broken?: [number, number] | undefined;
+        curve?: [number, number] | undefined;
+        cubic?: [[number, number], [number, number]] | undefined;
+        top: number;
+        id: string;
+        left: number;
+        lock?: boolean | undefined;
+        groupId?: string | undefined;
+        width: number;
+        link?: {
+            type: "web" | "slide";
+            target: string;
+        } | undefined;
+    } | {
+        type: "chart";
+        fill?: string | undefined;
+        chartType: import('../../../types/slides').ChartType;
+        data: {
+            labels: string[];
+            legends: string[];
+            series: number[][];
+        };
+        options?: {
+            axisX?: {
+                type?: import('chartist').IStepAxisStatic | undefined;
+                ticks?: Array<string> | Array<number> | undefined;
+                stretch?: boolean | undefined;
+                offset?: number | undefined;
+                position?: string | undefined;
+                labelOffset?: {
+                    x?: number | undefined;
+                    y?: number | undefined;
+                } | undefined;
+                showLabel?: boolean | undefined;
+                showGrid?: boolean | undefined;
+                labelInterpolationFnc?: Function | undefined;
+                scaleMinSpace?: number | undefined;
+                onlyInteger?: boolean | undefined;
+            } | {
+                type?: import('chartist').IFixedScaleAxisStatic | undefined;
+                high?: number | undefined;
+                low?: number | undefined;
+                divisor?: number | undefined;
+                ticks?: Array<string> | Array<number> | undefined;
+                offset?: number | undefined;
+                position?: string | undefined;
+                labelOffset?: {
+                    x?: number | undefined;
+                    y?: number | undefined;
+                } | undefined;
+                showLabel?: boolean | undefined;
+                showGrid?: boolean | undefined;
+                labelInterpolationFnc?: Function | undefined;
+                scaleMinSpace?: number | undefined;
+                onlyInteger?: boolean | undefined;
+            } | {
+                high?: number | undefined;
+                low?: number | undefined;
+                scaleMinSpace?: number | undefined;
+                onlyInteger?: boolean | undefined;
+                referenceValue?: number | undefined;
+                type?: import('chartist').IAutoScaleAxisStatic | undefined;
+                offset?: number | undefined;
+                position?: string | undefined;
+                labelOffset?: {
+                    x?: number | undefined;
+                    y?: number | undefined;
+                } | undefined;
+                showLabel?: boolean | undefined;
+                showGrid?: boolean | undefined;
+                labelInterpolationFnc?: Function | undefined;
+            } | undefined;
+            axisY?: {
+                type?: import('chartist').IStepAxisStatic | undefined;
+                ticks?: Array<string> | Array<number> | undefined;
+                stretch?: boolean | undefined;
+                offset?: number | undefined;
+                position?: string | undefined;
+                labelOffset?: {
+                    x?: number | undefined;
+                    y?: number | undefined;
+                } | undefined;
+                showLabel?: boolean | undefined;
+                showGrid?: boolean | undefined;
+                labelInterpolationFnc?: Function | undefined;
+                scaleMinSpace?: number | undefined;
+                onlyInteger?: boolean | undefined;
+            } | {
+                type?: import('chartist').IFixedScaleAxisStatic | undefined;
+                high?: number | undefined;
+                low?: number | undefined;
+                divisor?: number | undefined;
+                ticks?: Array<string> | Array<number> | undefined;
+                offset?: number | undefined;
+                position?: string | undefined;
+                labelOffset?: {
+                    x?: number | undefined;
+                    y?: number | undefined;
+                } | undefined;
+                showLabel?: boolean | undefined;
+                showGrid?: boolean | undefined;
+                labelInterpolationFnc?: Function | undefined;
+                scaleMinSpace?: number | undefined;
+                onlyInteger?: boolean | undefined;
+            } | {
+                high?: number | undefined;
+                low?: number | undefined;
+                scaleMinSpace?: number | undefined;
+                onlyInteger?: boolean | undefined;
+                referenceValue?: number | undefined;
+                type?: import('chartist').IAutoScaleAxisStatic | undefined;
+                offset?: number | undefined;
+                position?: string | undefined;
+                labelOffset?: {
+                    x?: number | undefined;
+                    y?: number | undefined;
+                } | undefined;
+                showLabel?: boolean | undefined;
+                showGrid?: boolean | undefined;
+                labelInterpolationFnc?: Function | undefined;
+            } | undefined;
+            width?: number | string | undefined;
+            height?: number | string | undefined;
+            showLine?: boolean | undefined;
+            showPoint?: boolean | undefined;
+            showArea?: boolean | undefined;
+            areaBase?: number | undefined;
+            lineSmooth?: Function | boolean | undefined;
+            low?: number | undefined;
+            high?: number | undefined;
+            ticks?: Array<string | number> | undefined;
+            chartPadding?: (import('chartist').IChartPadding & number) | {
+                top?: number | undefined;
+                right?: number | undefined;
+                bottom?: number | undefined;
+                left?: number | undefined;
+            } | undefined;
+            fullWidth?: boolean | undefined;
+            classNames?: {
+                chart?: string | undefined;
+                label?: string | undefined;
+                labelGroup?: string | undefined;
+                series?: string | undefined;
+                line?: string | undefined;
+                point?: string | undefined;
+                area?: string | undefined;
+                grid?: string | undefined;
+                gridGroup?: string | undefined;
+                gridBackground?: string | undefined;
+                vertical?: string | undefined;
+                horizontal?: string | undefined;
+                start?: string | undefined;
+                end?: string | undefined;
+                horizontalBars?: string | undefined;
+                bar?: string | undefined;
+                chartPie?: string | undefined;
+                chartDonut?: string | undefined;
+                slicePie?: string | undefined;
+                sliceDonut?: string | undefined;
+            } | undefined;
+            series?: {
+                [key: string]: {
+                    lineSmooth?: Function | boolean | undefined;
+                    showLine?: boolean | undefined;
+                    showPoint?: boolean | undefined;
+                    showArea?: boolean | undefined;
+                    areaBase?: number | undefined;
+                };
+            } | undefined;
+            reverseData?: boolean | undefined;
+            plugins?: Array<any> | undefined;
+            onlyInteger?: boolean | undefined;
+            seriesBarDistance?: number | undefined;
+            stackBars?: boolean | undefined;
+            stackMode?: "overlap" | "accumulate" | undefined;
+            horizontalBars?: boolean | undefined;
+            distributeSeries?: boolean | undefined;
+            startAngle?: number | undefined;
+            total?: number | undefined;
+            donut?: boolean | undefined;
+            donutSolid?: boolean | undefined;
+            donutWidth?: number | string | undefined;
+            showLabel?: boolean | undefined;
+            labelOffset?: number | undefined;
+            labelPosition?: string | undefined;
+            labelInterpolationFnc?: Function | undefined;
+            labelDirection?: string | undefined;
+            ignoreEmptyValues?: boolean | undefined;
+        } | undefined;
+        outline?: {
+            style?: ("dashed" | "solid") | undefined;
+            width?: number | undefined;
+            color?: string | undefined;
+        } | undefined;
+        themeColor: string[];
+        gridColor?: string | undefined;
+        legend?: ("" | "top" | "bottom") | undefined;
+        id: string;
+        left: number;
+        top: number;
+        lock?: boolean | undefined;
+        groupId?: string | undefined;
+        width: number;
+        height: number;
+        rotate: number;
+        link?: {
+            type: "web" | "slide";
+            target: string;
+        } | undefined;
+    } | {
+        type: "table";
+        outline: {
+            style?: ("dashed" | "solid") | undefined;
+            width?: number | undefined;
+            color?: string | undefined;
+        };
+        theme?: {
+            color: string;
+            rowHeader: boolean;
+            rowFooter: boolean;
+            colHeader: boolean;
+            colFooter: boolean;
+        } | undefined;
+        colWidths: number[];
+        data: {
+            id: string;
+            colspan: number;
+            rowspan: number;
+            text: string;
+            style?: {
+                bold?: boolean | undefined;
+                em?: boolean | undefined;
+                underline?: boolean | undefined;
+                strikethrough?: boolean | undefined;
+                color?: string | undefined;
+                backcolor?: string | undefined;
+                fontsize?: string | undefined;
+                fontname?: string | undefined;
+                align?: ("left" | "center" | "right") | undefined;
+            } | undefined;
+        }[][];
+        id: string;
+        left: number;
+        top: number;
+        lock?: boolean | undefined;
+        groupId?: string | undefined;
+        width: number;
+        height: number;
+        rotate: number;
+        link?: {
+            type: "web" | "slide";
+            target: string;
+        } | undefined;
+    } | {
+        type: "latex";
+        latex: string;
+        path: string;
+        color: string;
+        strokeWidth: number;
+        viewBox: [number, number];
+        fixedRatio: boolean;
+        id: string;
+        left: number;
+        top: number;
+        lock?: boolean | undefined;
+        groupId?: string | undefined;
+        width: number;
+        height: number;
+        rotate: number;
+        link?: {
+            type: "web" | "slide";
+            target: string;
+        } | undefined;
+    } | {
+        type: "video";
+        src: string;
+        poster?: string | undefined;
+        id: string;
+        left: number;
+        top: number;
+        lock?: boolean | undefined;
+        groupId?: string | undefined;
+        width: number;
+        height: number;
+        rotate: number;
+        link?: {
+            type: "web" | "slide";
+            target: string;
+        } | undefined;
+    } | {
+        type: "audio";
+        fixedRatio: boolean;
+        color: string;
+        loop: boolean;
+        autoplay: boolean;
+        src: string;
+        id: string;
+        left: number;
+        top: number;
+        lock?: boolean | undefined;
+        groupId?: string | undefined;
+        width: number;
+        height: number;
+        rotate: number;
+        link?: {
+            type: "web" | "slide";
+            target: string;
+        } | undefined;
+    })[], PPTElement[] | ({
+        type: "text";
+        content: string;
+        defaultFontName: string;
+        defaultColor: string;
+        outline?: {
+            style?: ("dashed" | "solid") | undefined;
+            width?: number | undefined;
+            color?: string | undefined;
+        } | undefined;
+        fill?: string | undefined;
+        lineHeight?: number | undefined;
+        wordSpace?: number | undefined;
+        opacity?: number | undefined;
+        shadow?: {
+            h: number;
+            v: number;
+            blur: number;
+            color: string;
+        } | undefined;
+        textIndent?: number | undefined;
+        paragraphSpace?: number | undefined;
+        textInsets?: [number, number, number, number] | undefined;
+        id: string;
+        left: number;
+        top: number;
+        lock?: boolean | undefined;
+        groupId?: string | undefined;
+        width: number;
+        height: number;
+        rotate: number;
+        link?: {
+            type: "web" | "slide";
+            target: string;
+        } | undefined;
+    } | {
+        type: "image";
+        fixedRatio: boolean;
+        src: string;
+        outline?: {
+            style?: ("dashed" | "solid") | undefined;
+            width?: number | undefined;
+            color?: string | undefined;
+        } | undefined;
+        filters?: {
+            blur?: string | undefined;
+            brightness?: string | undefined;
+            contrast?: string | undefined;
+            grayscale?: string | undefined;
+            saturate?: string | undefined;
+            'hue-rotate'?: string | undefined;
+            opacity?: string | undefined;
+        } | undefined;
+        clip?: {
+            range: [[number, number], [number, number]];
+            shape: string;
+        } | undefined;
+        flipH?: boolean | undefined;
+        flipV?: boolean | undefined;
+        shadow?: {
+            h: number;
+            v: number;
+            blur: number;
+            color: string;
+        } | undefined;
+        id: string;
+        left: number;
+        top: number;
+        lock?: boolean | undefined;
+        groupId?: string | undefined;
+        width: number;
+        height: number;
+        rotate: number;
+        link?: {
+            type: "web" | "slide";
+            target: string;
+        } | undefined;
+    } | {
+        type: "shape";
+        viewBox: [number, number];
+        path: string;
+        fixedRatio: boolean;
+        fill: string;
+        gradient?: {
+            type: "linear" | "radial";
+            color: [string, string];
+            rotate: number;
+        } | undefined;
+        outline?: {
+            style?: ("dashed" | "solid") | undefined;
+            width?: number | undefined;
+            color?: string | undefined;
+        } | undefined;
+        opacity?: number | undefined;
+        flipH?: boolean | undefined;
+        flipV?: boolean | undefined;
+        shadow?: {
+            h: number;
+            v: number;
+            blur: number;
+            color: string;
+        } | undefined;
+        special?: boolean | undefined;
+        text?: {
+            content: string;
+            defaultFontName: string;
+            defaultColor: string;
+            align: "top" | "middle" | "bottom";
+            textInsets?: [number, number, number, number] | undefined;
+        } | undefined;
+        pathFormula?: import('../../../types/slides').ShapePathFormulasKeys | undefined;
+        id: string;
+        left: number;
+        top: number;
+        lock?: boolean | undefined;
+        groupId?: string | undefined;
+        width: number;
+        height: number;
+        rotate: number;
+        link?: {
+            type: "web" | "slide";
+            target: string;
+        } | undefined;
+    } | {
+        type: "line";
+        start: [number, number];
+        end: [number, number];
+        style: "solid" | "dashed";
+        color: string;
+        points: [import('../../../types/slides').LinePoint, import('../../../types/slides').LinePoint];
+        shadow?: {
+            h: number;
+            v: number;
+            blur: number;
+            color: string;
+        } | undefined;
+        broken?: [number, number] | undefined;
+        curve?: [number, number] | undefined;
+        cubic?: [[number, number], [number, number]] | undefined;
+        top: number;
+        id: string;
+        left: number;
+        lock?: boolean | undefined;
+        groupId?: string | undefined;
+        width: number;
+        link?: {
+            type: "web" | "slide";
+            target: string;
+        } | undefined;
+    } | {
+        type: "chart";
+        fill?: string | undefined;
+        chartType: import('../../../types/slides').ChartType;
+        data: {
+            labels: string[];
+            legends: string[];
+            series: number[][];
+        };
+        options?: {
+            axisX?: {
+                type?: import('chartist').IStepAxisStatic | undefined;
+                ticks?: Array<string> | Array<number> | undefined;
+                stretch?: boolean | undefined;
+                offset?: number | undefined;
+                position?: string | undefined;
+                labelOffset?: {
+                    x?: number | undefined;
+                    y?: number | undefined;
+                } | undefined;
+                showLabel?: boolean | undefined;
+                showGrid?: boolean | undefined;
+                labelInterpolationFnc?: Function | undefined;
+                scaleMinSpace?: number | undefined;
+                onlyInteger?: boolean | undefined;
+            } | {
+                type?: import('chartist').IFixedScaleAxisStatic | undefined;
+                high?: number | undefined;
+                low?: number | undefined;
+                divisor?: number | undefined;
+                ticks?: Array<string> | Array<number> | undefined;
+                offset?: number | undefined;
+                position?: string | undefined;
+                labelOffset?: {
+                    x?: number | undefined;
+                    y?: number | undefined;
+                } | undefined;
+                showLabel?: boolean | undefined;
+                showGrid?: boolean | undefined;
+                labelInterpolationFnc?: Function | undefined;
+                scaleMinSpace?: number | undefined;
+                onlyInteger?: boolean | undefined;
+            } | {
+                high?: number | undefined;
+                low?: number | undefined;
+                scaleMinSpace?: number | undefined;
+                onlyInteger?: boolean | undefined;
+                referenceValue?: number | undefined;
+                type?: import('chartist').IAutoScaleAxisStatic | undefined;
+                offset?: number | undefined;
+                position?: string | undefined;
+                labelOffset?: {
+                    x?: number | undefined;
+                    y?: number | undefined;
+                } | undefined;
+                showLabel?: boolean | undefined;
+                showGrid?: boolean | undefined;
+                labelInterpolationFnc?: Function | undefined;
+            } | undefined;
+            axisY?: {
+                type?: import('chartist').IStepAxisStatic | undefined;
+                ticks?: Array<string> | Array<number> | undefined;
+                stretch?: boolean | undefined;
+                offset?: number | undefined;
+                position?: string | undefined;
+                labelOffset?: {
+                    x?: number | undefined;
+                    y?: number | undefined;
+                } | undefined;
+                showLabel?: boolean | undefined;
+                showGrid?: boolean | undefined;
+                labelInterpolationFnc?: Function | undefined;
+                scaleMinSpace?: number | undefined;
+                onlyInteger?: boolean | undefined;
+            } | {
+                type?: import('chartist').IFixedScaleAxisStatic | undefined;
+                high?: number | undefined;
+                low?: number | undefined;
+                divisor?: number | undefined;
+                ticks?: Array<string> | Array<number> | undefined;
+                offset?: number | undefined;
+                position?: string | undefined;
+                labelOffset?: {
+                    x?: number | undefined;
+                    y?: number | undefined;
+                } | undefined;
+                showLabel?: boolean | undefined;
+                showGrid?: boolean | undefined;
+                labelInterpolationFnc?: Function | undefined;
+                scaleMinSpace?: number | undefined;
+                onlyInteger?: boolean | undefined;
+            } | {
+                high?: number | undefined;
+                low?: number | undefined;
+                scaleMinSpace?: number | undefined;
+                onlyInteger?: boolean | undefined;
+                referenceValue?: number | undefined;
+                type?: import('chartist').IAutoScaleAxisStatic | undefined;
+                offset?: number | undefined;
+                position?: string | undefined;
+                labelOffset?: {
+                    x?: number | undefined;
+                    y?: number | undefined;
+                } | undefined;
+                showLabel?: boolean | undefined;
+                showGrid?: boolean | undefined;
+                labelInterpolationFnc?: Function | undefined;
+            } | undefined;
+            width?: number | string | undefined;
+            height?: number | string | undefined;
+            showLine?: boolean | undefined;
+            showPoint?: boolean | undefined;
+            showArea?: boolean | undefined;
+            areaBase?: number | undefined;
+            lineSmooth?: Function | boolean | undefined;
+            low?: number | undefined;
+            high?: number | undefined;
+            ticks?: Array<string | number> | undefined;
+            chartPadding?: (import('chartist').IChartPadding & number) | {
+                top?: number | undefined;
+                right?: number | undefined;
+                bottom?: number | undefined;
+                left?: number | undefined;
+            } | undefined;
+            fullWidth?: boolean | undefined;
+            classNames?: {
+                chart?: string | undefined;
+                label?: string | undefined;
+                labelGroup?: string | undefined;
+                series?: string | undefined;
+                line?: string | undefined;
+                point?: string | undefined;
+                area?: string | undefined;
+                grid?: string | undefined;
+                gridGroup?: string | undefined;
+                gridBackground?: string | undefined;
+                vertical?: string | undefined;
+                horizontal?: string | undefined;
+                start?: string | undefined;
+                end?: string | undefined;
+                horizontalBars?: string | undefined;
+                bar?: string | undefined;
+                chartPie?: string | undefined;
+                chartDonut?: string | undefined;
+                slicePie?: string | undefined;
+                sliceDonut?: string | undefined;
+            } | undefined;
+            series?: {
+                [key: string]: {
+                    lineSmooth?: Function | boolean | undefined;
+                    showLine?: boolean | undefined;
+                    showPoint?: boolean | undefined;
+                    showArea?: boolean | undefined;
+                    areaBase?: number | undefined;
+                };
+            } | undefined;
+            reverseData?: boolean | undefined;
+            plugins?: Array<any> | undefined;
+            onlyInteger?: boolean | undefined;
+            seriesBarDistance?: number | undefined;
+            stackBars?: boolean | undefined;
+            stackMode?: "overlap" | "accumulate" | undefined;
+            horizontalBars?: boolean | undefined;
+            distributeSeries?: boolean | undefined;
+            startAngle?: number | undefined;
+            total?: number | undefined;
+            donut?: boolean | undefined;
+            donutSolid?: boolean | undefined;
+            donutWidth?: number | string | undefined;
+            showLabel?: boolean | undefined;
+            labelOffset?: number | undefined;
+            labelPosition?: string | undefined;
+            labelInterpolationFnc?: Function | undefined;
+            labelDirection?: string | undefined;
+            ignoreEmptyValues?: boolean | undefined;
+        } | undefined;
+        outline?: {
+            style?: ("dashed" | "solid") | undefined;
+            width?: number | undefined;
+            color?: string | undefined;
+        } | undefined;
+        themeColor: string[];
+        gridColor?: string | undefined;
+        legend?: ("" | "top" | "bottom") | undefined;
+        id: string;
+        left: number;
+        top: number;
+        lock?: boolean | undefined;
+        groupId?: string | undefined;
+        width: number;
+        height: number;
+        rotate: number;
+        link?: {
+            type: "web" | "slide";
+            target: string;
+        } | undefined;
+    } | {
+        type: "table";
+        outline: {
+            style?: ("dashed" | "solid") | undefined;
+            width?: number | undefined;
+            color?: string | undefined;
+        };
+        theme?: {
+            color: string;
+            rowHeader: boolean;
+            rowFooter: boolean;
+            colHeader: boolean;
+            colFooter: boolean;
+        } | undefined;
+        colWidths: number[];
+        data: {
+            id: string;
+            colspan: number;
+            rowspan: number;
+            text: string;
+            style?: {
+                bold?: boolean | undefined;
+                em?: boolean | undefined;
+                underline?: boolean | undefined;
+                strikethrough?: boolean | undefined;
+                color?: string | undefined;
+                backcolor?: string | undefined;
+                fontsize?: string | undefined;
+                fontname?: string | undefined;
+                align?: ("left" | "center" | "right") | undefined;
+            } | undefined;
+        }[][];
+        id: string;
+        left: number;
+        top: number;
+        lock?: boolean | undefined;
+        groupId?: string | undefined;
+        width: number;
+        height: number;
+        rotate: number;
+        link?: {
+            type: "web" | "slide";
+            target: string;
+        } | undefined;
+    } | {
+        type: "latex";
+        latex: string;
+        path: string;
+        color: string;
+        strokeWidth: number;
+        viewBox: [number, number];
+        fixedRatio: boolean;
+        id: string;
+        left: number;
+        top: number;
+        lock?: boolean | undefined;
+        groupId?: string | undefined;
+        width: number;
+        height: number;
+        rotate: number;
+        link?: {
+            type: "web" | "slide";
+            target: string;
+        } | undefined;
+    } | {
+        type: "video";
+        src: string;
+        poster?: string | undefined;
+        id: string;
+        left: number;
+        top: number;
+        lock?: boolean | undefined;
+        groupId?: string | undefined;
+        width: number;
+        height: number;
+        rotate: number;
+        link?: {
+            type: "web" | "slide";
+            target: string;
+        } | undefined;
+    } | {
+        type: "audio";
+        fixedRatio: boolean;
+        color: string;
+        loop: boolean;
+        autoplay: boolean;
+        src: string;
+        id: string;
+        left: number;
+        top: number;
+        lock?: boolean | undefined;
+        groupId?: string | undefined;
+        width: number;
+        height: number;
+        rotate: number;
+        link?: {
+            type: "web" | "slide";
+            target: string;
+        } | undefined;
+    })[]>;
+    activeElementIdList: import('vue').Ref<string[], string[]>;
+    handleElementId: import('vue').Ref<string, string>;
+    activeGroupElementId: import('vue').Ref<string, string>;
+    canvasRef: import('vue').Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    viewportRef: import('vue').Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    viewportStyles: import('vue').ComputedRef<{
+        width: number;
+        height: number;
+        left: number;
+        top: number;
+    }>;
+    canvasScale: import('vue').Ref<number, number>;
+    mouseSelection: import('vue').Ref<{
+        top: number;
+        left: number;
+        width: number;
+        height: number;
+    }, {
+        top: number;
+        left: number;
+        width: number;
+        height: number;
+    } | {
+        top: number;
+        left: number;
+        width: number;
+        height: number;
+    }>;
+    mouseSelectionVisible: import('vue').Ref<boolean, boolean>;
+    mouseSelectionQuadrant: import('vue').Ref<number, number>;
+    creatingElement: import('vue').Ref<import('../../../types/edit').CreatingElement | null, import('../../../types/edit').CreatingElement | null>;
+    alignmentLines: import('vue').Ref<{
+        type: "vertical" | "horizontal";
+        axis: {
+            x: number;
+            y: number;
+        };
+        length: number;
+    }[], AlignmentLineProps[] | {
+        type: "vertical" | "horizontal";
+        axis: {
+            x: number;
+            y: number;
+        };
+        length: number;
+    }[]>;
+    linkDialogVisible: import('vue').Ref<boolean, boolean>;
+    spaceKeyState: import('vue').Ref<boolean, boolean>;
+    showRuler: import('vue').Ref<boolean, boolean>;
+    openLinkDialog: () => boolean;
+    handleClickBlankArea: (e: MouseEvent) => void;
+    removeEditorAreaFocus: () => void;
+    insertElementFromCreateSelection: (selectionData: import('../../../types/edit').CreateElementSelectionData) => void;
+    selectElement: (e: MouseEvent, element: PPTElement, startMove?: boolean) => void;
+    rotateElement: (element: Exclude<PPTElement, import('../../../types/slides').PPTLineElement | import('../../../types/slides').PPTVideoElement | import('../../../types/slides').PPTAudioElement>) => void;
+    scaleElement: (e: MouseEvent, element: Exclude<PPTElement, import('../../../types/slides').PPTLineElement>, command: import('../../../types/edit').OperateResizeHandlers) => void;
+    dragLineElement: (e: MouseEvent, element: import('../../../types/slides').PPTLineElement, command: import('../../../types/edit').OperateLineHandlers) => void;
+    scaleMultiElement: (e: MouseEvent, range: import('../../../types/edit').MultiSelectRange, command: import('../../../types/edit').OperateResizeHandlers) => void;
+    handleMousewheelCanvas: (e: WheelEvent) => void;
+    contextmenus: () => ContextmenuItem[];
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {
+    EditableElement: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        elementInfo: {
+            type: import('vue').PropType<PPTElement>;
+            required: true;
+        };
+        elementIndex: {
+            type: NumberConstructor;
+            required: true;
+        };
+        isMultiSelect: {
+            type: BooleanConstructor;
+            required: true;
+        };
+        selectElement: {
+            type: import('vue').PropType<(e: MouseEvent, element: PPTElement, canMove?: boolean) => void>;
+            required: true;
+        };
+        openLinkDialog: {
+            type: import('vue').PropType<() => void>;
+            required: true;
+        };
+    }>, {
+        currentElementComponent: import('vue').ComputedRef<import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            elementInfo: {
+                type: import('vue').PropType<import('../../../types/slides').PPTImageElement>;
+                required: true;
+            };
+            selectElement: {
+                type: import('vue').PropType<(e: MouseEvent, element: import('../../../types/slides').PPTImageElement, canMove?: boolean) => void>;
+                required: true;
+            };
+            contextmenus: {
+                type: import('vue').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: import('vue').PropType<import('../../../types/slides').PPTImageElement>;
+                required: true;
+            };
+            selectElement: {
+                type: import('vue').PropType<(e: MouseEvent, element: import('../../../types/slides').PPTImageElement, canMove?: boolean) => void>;
+                required: true;
+            };
+            contextmenus: {
+                type: import('vue').PropType<() => ContextmenuItem[]>;
+            };
+        }>> & Readonly<{}>, {}, {}, {
+            ImageOutline: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                elementInfo: {
+                    type: import('vue').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: import('vue').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: import('vue').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: import('vue').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: import('vue').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: import('vue').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: import('vue').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: import('vue').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: import('vue').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: import('vue').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: import('vue').PropType<import('../../../types/slides').PPTTextElement>;
+                required: true;
+            };
+            selectElement: {
+                type: import('vue').PropType<(e: MouseEvent, element: import('../../../types/slides').PPTTextElement, canMove?: boolean) => void>;
+                required: true;
+            };
+            contextmenus: {
+                type: import('vue').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: import('vue').PropType<import('../../../types/slides').PPTTextElement>;
+                required: true;
+            };
+            selectElement: {
+                type: import('vue').PropType<(e: MouseEvent, element: import('../../../types/slides').PPTTextElement, canMove?: boolean) => void>;
+                required: true;
+            };
+            contextmenus: {
+                type: import('vue').PropType<() => ContextmenuItem[]>;
+            };
+        }>> & Readonly<{}>, {}, {}, {
+            ElementOutline: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                width: {
+                    type: NumberConstructor;
+                    required: true;
+                };
+                height: {
+                    type: NumberConstructor;
+                    required: true;
+                };
+                outline: {
+                    type: import('vue').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: import('vue').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: import('vue').PropType<import('../../../types/slides').PPTShapeElement>;
+                required: true;
+            };
+            selectElement: {
+                type: import('vue').PropType<(e: MouseEvent, element: import('../../../types/slides').PPTShapeElement, canMove?: boolean) => void>;
+                required: true;
+            };
+            contextmenus: {
+                type: import('vue').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: import('vue').PropType<import('../../../types/slides').PPTShapeElement>;
+                required: true;
+            };
+            selectElement: {
+                type: import('vue').PropType<(e: MouseEvent, element: import('../../../types/slides').PPTShapeElement, canMove?: boolean) => void>;
+                required: true;
+            };
+            contextmenus: {
+                type: import('vue').PropType<() => ContextmenuItem[]>;
+            };
+        }>> & Readonly<{}>, {}, {}, {
+            GradientDefs: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                id: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                type: {
+                    type: import('vue').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: import('vue').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: import('vue').PropType<import('../../../types/slides').PPTLineElement>;
+                required: true;
+            };
+            selectElement: {
+                type: import('vue').PropType<(e: MouseEvent, element: import('../../../types/slides').PPTLineElement, canMove?: boolean) => void>;
+                required: true;
+            };
+            contextmenus: {
+                type: import('vue').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: import('vue').PropType<import('../../../types/slides').PPTLineElement>;
+                required: true;
+            };
+            selectElement: {
+                type: import('vue').PropType<(e: MouseEvent, element: import('../../../types/slides').PPTLineElement, canMove?: boolean) => void>;
+                required: true;
+            };
+            contextmenus: {
+                type: import('vue').PropType<() => ContextmenuItem[]>;
+            };
+        }>> & Readonly<{}>, {}, {}, {
+            LinePointMarker: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                id: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                position: {
+                    type: import('vue').PropType<"start" | "end">;
+                    required: true;
+                };
+                type: {
+                    type: import('vue').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: import('vue').PropType<"start" | "end">;
+                    required: true;
+                };
+                type: {
+                    type: import('vue').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: import('vue').PropType<import('../../../types/slides').PPTChartElement>;
+                required: true;
+            };
+            selectElement: {
+                type: import('vue').PropType<(e: MouseEvent, element: import('../../../types/slides').PPTChartElement, canMove?: boolean) => void>;
+                required: true;
+            };
+            contextmenus: {
+                type: import('vue').PropType<() => ContextmenuItem[]>;
+            };
+        }>, {
+            handleSelectElement: (e: MouseEvent) => void;
+            openDataEditor: () => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            elementInfo: {
+                type: import('vue').PropType<import('../../../types/slides').PPTChartElement>;
+                required: true;
+            };
+            selectElement: {
+                type: import('vue').PropType<(e: MouseEvent, element: import('../../../types/slides').PPTChartElement, canMove?: boolean) => void>;
+                required: true;
+            };
+            contextmenus: {
+                type: import('vue').PropType<() => ContextmenuItem[]>;
+            };
+        }>> & Readonly<{}>, {}, {}, {
+            ElementOutline: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                width: {
+                    type: NumberConstructor;
+                    required: true;
+                };
+                height: {
+                    type: NumberConstructor;
+                    required: true;
+                };
+                outline: {
+                    type: import('vue').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: import('vue').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: import('vue').PropType<import('../../../types/slides').ChartType>;
+                    required: true;
+                };
+                data: {
+                    type: import('vue').PropType<import('../../../types/slides').ChartData>;
+                    required: true;
+                };
+                options: {
+                    type: import('vue').PropType<import('../../../types/slides').ChartOptions>;
+                };
+                themeColor: {
+                    type: import('vue').PropType<string[]>;
+                    required: true;
+                };
+                legends: {
+                    type: import('vue').PropType<string[]>;
+                    required: true;
+                };
+                gridColor: {
+                    type: StringConstructor;
+                };
+                legend: {
+                    type: import('vue').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: import('vue').PropType<import('../../../types/slides').ChartType>;
+                    required: true;
+                };
+                data: {
+                    type: import('vue').PropType<import('../../../types/slides').ChartData>;
+                    required: true;
+                };
+                options: {
+                    type: import('vue').PropType<import('../../../types/slides').ChartOptions>;
+                };
+                themeColor: {
+                    type: import('vue').PropType<string[]>;
+                    required: true;
+                };
+                legends: {
+                    type: import('vue').PropType<string[]>;
+                    required: true;
+                };
+                gridColor: {
+                    type: StringConstructor;
+                };
+                legend: {
+                    type: import('vue').PropType<"" | "top" | "bottom">;
+                };
+            }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any> | import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            elementInfo: {
+                type: import('vue').PropType<import('../../../types/slides').PPTTableElement>;
+                required: true;
+            };
+            selectElement: {
+                type: import('vue').PropType<(e: MouseEvent, element: import('../../../types/slides').PPTTableElement, canMove?: boolean) => void>;
+                required: true;
+            };
+            contextmenus: {
+                type: import('vue').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: import('vue').PropType<import('../../../types/slides').PPTTableElement>;
+                required: true;
+            };
+            selectElement: {
+                type: import('vue').PropType<(e: MouseEvent, element: import('../../../types/slides').PPTTableElement, canMove?: boolean) => void>;
+                required: true;
+            };
+            contextmenus: {
+                type: import('vue').PropType<() => ContextmenuItem[]>;
+            };
+        }>> & Readonly<{}>, {}, {}, {
+            EditableTable: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                data: {
+                    type: import('vue').PropType<import('../../../types/slides').TableCell[][]>;
+                    required: true;
+                };
+                width: {
+                    type: NumberConstructor;
+                    required: true;
+                };
+                colWidths: {
+                    type: import('vue').PropType<number[]>;
+                    required: true;
+                };
+                outline: {
+                    type: import('vue').PropType<import('../../../types/slides').PPTElementOutline>;
+                    required: true;
+                };
+                theme: {
+                    type: import('vue').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: import('vue').PropType<import('../../../types/slides').TableCell[][]>;
+                    required: true;
+                };
+                width: {
+                    type: NumberConstructor;
+                    required: true;
+                };
+                colWidths: {
+                    type: import('vue').PropType<number[]>;
+                    required: true;
+                };
+                outline: {
+                    type: import('vue').PropType<import('../../../types/slides').PPTElementOutline>;
+                    required: true;
+                };
+                theme: {
+                    type: import('vue').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: import('vue').PropType<import('../../../types/slides').PPTLatexElement>;
+                required: true;
+            };
+            selectElement: {
+                type: import('vue').PropType<(e: MouseEvent, element: import('../../../types/slides').PPTLatexElement, canMove?: boolean) => void>;
+                required: true;
+            };
+            contextmenus: {
+                type: import('vue').PropType<() => ContextmenuItem[]>;
+            };
+        }>, {
+            handleSelectElement: (e: MouseEvent) => void;
+            openLatexEditor: () => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            elementInfo: {
+                type: import('vue').PropType<import('../../../types/slides').PPTLatexElement>;
+                required: true;
+            };
+            selectElement: {
+                type: import('vue').PropType<(e: MouseEvent, element: import('../../../types/slides').PPTLatexElement, canMove?: boolean) => void>;
+                required: true;
+            };
+            contextmenus: {
+                type: import('vue').PropType<() => ContextmenuItem[]>;
+            };
+        }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any> | import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            elementInfo: {
+                type: import('vue').PropType<import('../../../types/slides').PPTVideoElement>;
+                required: true;
+            };
+            selectElement: {
+                type: import('vue').PropType<(e: MouseEvent, element: import('../../../types/slides').PPTVideoElement, canMove?: boolean) => void>;
+                required: true;
+            };
+            contextmenus: {
+                type: import('vue').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: import('vue').PropType<import('../../../types/slides').PPTVideoElement>;
+                required: true;
+            };
+            selectElement: {
+                type: import('vue').PropType<(e: MouseEvent, element: import('../../../types/slides').PPTVideoElement, canMove?: boolean) => void>;
+                required: true;
+            };
+            contextmenus: {
+                type: import('vue').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: import('vue').PropType<import('../../../types/slides').PPTAudioElement>;
+                required: true;
+            };
+            selectElement: {
+                type: import('vue').PropType<(e: MouseEvent, element: import('../../../types/slides').PPTAudioElement, canMove?: boolean) => void>;
+                required: true;
+            };
+            contextmenus: {
+                type: import('vue').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: import('vue').PropType<import('../../../types/slides').PPTAudioElement>;
+                required: true;
+            };
+            selectElement: {
+                type: import('vue').PropType<(e: MouseEvent, element: import('../../../types/slides').PPTAudioElement, canMove?: boolean) => void>;
+                required: true;
+            };
+            contextmenus: {
+                type: import('vue').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: import('vue').PropType<PPTElement>;
+            required: true;
+        };
+        elementIndex: {
+            type: NumberConstructor;
+            required: true;
+        };
+        isMultiSelect: {
+            type: BooleanConstructor;
+            required: true;
+        };
+        selectElement: {
+            type: import('vue').PropType<(e: MouseEvent, element: PPTElement, canMove?: boolean) => void>;
+            required: true;
+        };
+        openLinkDialog: {
+            type: import('vue').PropType<() => void>;
+            required: true;
+        };
+    }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    MouseSelection: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        top: {
+            type: NumberConstructor;
+            required: true;
+        };
+        left: {
+            type: NumberConstructor;
+            required: true;
+        };
+        width: {
+            type: NumberConstructor;
+            required: true;
+        };
+        height: {
+            type: NumberConstructor;
+            required: true;
+        };
+        quadrant: {
+            type: NumberConstructor;
+            required: true;
+            validator(value: number): boolean;
+        };
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        top: {
+            type: NumberConstructor;
+            required: true;
+        };
+        left: {
+            type: NumberConstructor;
+            required: true;
+        };
+        width: {
+            type: NumberConstructor;
+            required: true;
+        };
+        height: {
+            type: NumberConstructor;
+            required: true;
+        };
+        quadrant: {
+            type: NumberConstructor;
+            required: true;
+            validator(value: number): boolean;
+        };
+    }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    ViewportBackground: import('vue').DefineComponent<{}, {
+        showGridLines: import('vue').Ref<boolean, boolean>;
+        backgroundStyle: import('vue').ComputedRef<{
+            backgroundColor: string | undefined;
+            backgroundImage?: undefined;
+            backgroundRepeat?: undefined;
+            backgroundSize?: undefined;
+        } | {
+            backgroundImage: string;
+            backgroundRepeat: string;
+            backgroundSize: string;
+            backgroundColor?: undefined;
+        } | {
+            backgroundImage: string;
+            backgroundColor?: undefined;
+            backgroundRepeat?: undefined;
+            backgroundSize?: undefined;
+        }>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {
+        GridLines: import('vue').DefineComponent<{}, {
+            canvasScale: import('vue').Ref<number, number>;
+            gridColor: import('vue').ComputedRef<string>;
+            width: number;
+            height: number;
+            path: string;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    AlignmentLine: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        type: {
+            type: import('vue').PropType<"vertical" | "horizontal">;
+            required: true;
+        };
+        axis: {
+            type: import('vue').PropType<import('../../../types/edit').AlignmentLineAxis>;
+            required: true;
+        };
+        length: {
+            type: NumberConstructor;
+            required: true;
+        };
+    }>, {
+        left: import('vue').ComputedRef<string>;
+        top: import('vue').ComputedRef<string>;
+        sizeStyle: import('vue').ComputedRef<{
+            height: string;
+            width?: undefined;
+        } | {
+            width: string;
+            height?: undefined;
+        }>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        type: {
+            type: import('vue').PropType<"vertical" | "horizontal">;
+            required: true;
+        };
+        axis: {
+            type: import('vue').PropType<import('../../../types/edit').AlignmentLineAxis>;
+            required: true;
+        };
+        length: {
+            type: NumberConstructor;
+            required: true;
+        };
+    }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    Ruler: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        viewportStyles: {
+            type: import('vue').PropType<import('./Ruler.vue').ViewportStyles>;
+            required: true;
+        };
+    }>, {
+        canvasScale: import('vue').Ref<number, number>;
+        markerSize: import('vue').ComputedRef<number>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        viewportStyles: {
+            type: import('vue').PropType<import('./Ruler.vue').ViewportStyles>;
+            required: true;
+        };
+    }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    ElementCreateSelection: import('vue').DefineComponent<{}, {
+        selectionRef: import('vue').Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        start: import('vue').Ref<[number, number] | undefined, [number, number] | undefined>;
+        end: import('vue').Ref<[number, number] | undefined, [number, number] | undefined>;
+        creatingElement: import('vue').Ref<import('../../../types/edit').CreatingElement | null, import('../../../types/edit').CreatingElement | null>;
+        createSelection: (e: MouseEvent) => void;
+        lineData: import('vue').ComputedRef<{
+            svgWidth: number;
+            svgHeight: number;
+            startX: number;
+            startY: number;
+            endX: number;
+            endY: number;
+            path: string;
+        } | null>;
+        position: import('vue').ComputedRef<{
+            left?: undefined;
+            top?: undefined;
+            width?: undefined;
+            height?: undefined;
+        } | {
+            left: string;
+            top: string;
+            width: string;
+            height: string;
+        }>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "created"[], "created", import('vue').PublicProps, Readonly<{}> & Readonly<{
+        onCreated?: ((...args: any[]) => any) | undefined;
+    }>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    MultiSelectOperate: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        elementList: {
+            type: import('vue').PropType<PPTElement[]>;
+            required: true;
+        };
+        scaleMultiElement: {
+            type: import('vue').PropType<(e: MouseEvent, range: import('../../../types/edit').MultiSelectRange, command: import('../../../types/edit').OperateResizeHandlers) => void>;
+            required: true;
+        };
+    }>, {
+        range: import('vue').Ref<{
+            minX: number;
+            maxX: number;
+            minY: number;
+            maxY: number;
+        }, {
+            minX: number;
+            maxX: number;
+            minY: number;
+            maxY: number;
+        } | {
+            minX: number;
+            maxX: number;
+            minY: number;
+            maxY: number;
+        }>;
+        canvasScale: import('vue').Ref<number, number>;
+        borderLines: import('vue').ComputedRef<({
+            type: import('../../../types/edit').OperateBorderLines;
+            style: {
+                width: string;
+                top?: undefined;
+                height?: undefined;
+                left?: undefined;
+            };
+        } | {
+            type: import('../../../types/edit').OperateBorderLines;
+            style: {
+                top: string;
+                width: string;
+                height?: undefined;
+                left?: undefined;
+            };
+        } | {
+            type: import('../../../types/edit').OperateBorderLines;
+            style: {
+                height: string;
+                width?: undefined;
+                top?: undefined;
+                left?: undefined;
+            };
+        } | {
+            type: import('../../../types/edit').OperateBorderLines;
+            style: {
+                left: string;
+                height: string;
+                width?: undefined;
+                top?: undefined;
+            };
+        })[]>;
+        disableResize: import('vue').ComputedRef<boolean>;
+        resizeHandlers: import('vue').ComputedRef<({
+            direction: import('../../../types/edit').OperateResizeHandlers;
+            style: {
+                left?: undefined;
+                top?: undefined;
+            };
+        } | {
+            direction: import('../../../types/edit').OperateResizeHandlers;
+            style: {
+                left: string;
+                top?: undefined;
+            };
+        } | {
+            direction: import('../../../types/edit').OperateResizeHandlers;
+            style: {
+                top: string;
+                left?: undefined;
+            };
+        } | {
+            direction: import('../../../types/edit').OperateResizeHandlers;
+            style: {
+                left: string;
+                top: string;
+            };
+        })[]>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        elementList: {
+            type: import('vue').PropType<PPTElement[]>;
+            required: true;
+        };
+        scaleMultiElement: {
+            type: import('vue').PropType<(e: MouseEvent, range: import('../../../types/edit').MultiSelectRange, command: import('../../../types/edit').OperateResizeHandlers) => void>;
+            required: true;
+        };
+    }>> & Readonly<{}>, {}, {}, {
+        ResizeHandler: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            type: {
+                type: import('vue').PropType<import('../../../types/edit').OperateResizeHandlers>;
+                default: string;
+            };
+            rotate: {
+                type: NumberConstructor;
+                default: number;
+            };
+        }>, {
+            rotateClassName: import('vue').ComputedRef<string>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            type: {
+                type: import('vue').PropType<import('../../../types/edit').OperateResizeHandlers>;
+                default: string;
+            };
+            rotate: {
+                type: NumberConstructor;
+                default: number;
+            };
+        }>> & Readonly<{}>, {
+            rotate: number;
+            type: import('../../../types/edit').OperateResizeHandlers;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        BorderLine: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            type: {
+                type: import('vue').PropType<import('../../../types/edit').OperateBorderLines>;
+                required: true;
+            };
+            isWide: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            type: {
+                type: import('vue').PropType<import('../../../types/edit').OperateBorderLines>;
+                required: true;
+            };
+            isWide: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{}>, {
+            isWide: boolean;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    Operate: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        elementInfo: {
+            type: import('vue').PropType<PPTElement>;
+            required: true;
+        };
+        isSelected: {
+            type: BooleanConstructor;
+            required: true;
+        };
+        isActive: {
+            type: BooleanConstructor;
+            required: true;
+        };
+        isActiveGroupElement: {
+            type: BooleanConstructor;
+            required: true;
+        };
+        isMultiSelect: {
+            type: BooleanConstructor;
+            required: true;
+        };
+        rotateElement: {
+            type: import('vue').PropType<(element: Exclude<PPTElement, import('../../../types/slides').PPTLineElement | import('../../../types/slides').PPTVideoElement | import('../../../types/slides').PPTAudioElement>) => void>;
+            required: true;
+        };
+        scaleElement: {
+            type: import('vue').PropType<(e: MouseEvent, element: Exclude<PPTElement, import('../../../types/slides').PPTLineElement>, command: import('../../../types/edit').OperateResizeHandlers) => void>;
+            required: true;
+        };
+        dragLineElement: {
+            type: import('vue').PropType<(e: MouseEvent, element: import('../../../types/slides').PPTLineElement, command: import('../../../types/edit').OperateLineHandlers) => void>;
+            required: true;
+        };
+        openLinkDialog: {
+            type: import('vue').PropType<() => void>;
+            required: true;
+        };
+    }>, {
+        currentOperateComponent: import('vue').ComputedRef<import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            elementInfo: {
+                type: import('vue').PropType<import('../../../types/slides').PPTImageElement>;
+                required: true;
+            };
+            handlerVisible: {
+                type: BooleanConstructor;
+                required: true;
+            };
+            rotateElement: {
+                type: import('vue').PropType<(element: import('../../../types/slides').PPTImageElement) => void>;
+                required: true;
+            };
+            scaleElement: {
+                type: import('vue').PropType<(e: MouseEvent, element: import('../../../types/slides').PPTImageElement, command: import('../../../types/edit').OperateResizeHandlers) => void>;
+                required: true;
+            };
+        }>, {
+            isCliping: import('vue').ComputedRef<boolean>;
+            scaleWidth: import('vue').ComputedRef<number>;
+            resizeHandlers: import('vue').ComputedRef<({
+                direction: import('../../../types/edit').OperateResizeHandlers;
+                style: {
+                    left?: undefined;
+                    top?: undefined;
+                };
+            } | {
+                direction: import('../../../types/edit').OperateResizeHandlers;
+                style: {
+                    left: string;
+                    top?: undefined;
+                };
+            } | {
+                direction: import('../../../types/edit').OperateResizeHandlers;
+                style: {
+                    top: string;
+                    left?: undefined;
+                };
+            } | {
+                direction: import('../../../types/edit').OperateResizeHandlers;
+                style: {
+                    left: string;
+                    top: string;
+                };
+            })[]>;
+            borderLines: import('vue').ComputedRef<({
+                type: import('../../../types/edit').OperateBorderLines;
+                style: {
+                    width: string;
+                    top?: undefined;
+                    height?: undefined;
+                    left?: undefined;
+                };
+            } | {
+                type: import('../../../types/edit').OperateBorderLines;
+                style: {
+                    top: string;
+                    width: string;
+                    height?: undefined;
+                    left?: undefined;
+                };
+            } | {
+                type: import('../../../types/edit').OperateBorderLines;
+                style: {
+                    height: string;
+                    width?: undefined;
+                    top?: undefined;
+                    left?: undefined;
+                };
+            } | {
+                type: import('../../../types/edit').OperateBorderLines;
+                style: {
+                    left: string;
+                    height: string;
+                    width?: undefined;
+                    top?: undefined;
+                };
+            })[]>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            elementInfo: {
+                type: import('vue').PropType<import('../../../types/slides').PPTImageElement>;
+                required: true;
+            };
+            handlerVisible: {
+                type: BooleanConstructor;
+                required: true;
+            };
+            rotateElement: {
+                type: import('vue').PropType<(element: import('../../../types/slides').PPTImageElement) => void>;
+                required: true;
+            };
+            scaleElement: {
+                type: import('vue').PropType<(e: MouseEvent, element: import('../../../types/slides').PPTImageElement, command: import('../../../types/edit').OperateResizeHandlers) => void>;
+                required: true;
+            };
+        }>> & Readonly<{}>, {}, {}, {
+            RotateHandler: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            ResizeHandler: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                type: {
+                    type: import('vue').PropType<import('../../../types/edit').OperateResizeHandlers>;
+                    default: string;
+                };
+                rotate: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+            }>, {
+                rotateClassName: import('vue').ComputedRef<string>;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                type: {
+                    type: import('vue').PropType<import('../../../types/edit').OperateResizeHandlers>;
+                    default: string;
+                };
+                rotate: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+            }>> & Readonly<{}>, {
+                rotate: number;
+                type: import('../../../types/edit').OperateResizeHandlers;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            BorderLine: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                type: {
+                    type: import('vue').PropType<import('../../../types/edit').OperateBorderLines>;
+                    required: true;
+                };
+                isWide: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                type: {
+                    type: import('vue').PropType<import('../../../types/edit').OperateBorderLines>;
+                    required: true;
+                };
+                isWide: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                isWide: boolean;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any> | import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            elementInfo: {
+                type: import('vue').PropType<import('../../../types/slides').PPTTextElement>;
+                required: true;
+            };
+            handlerVisible: {
+                type: BooleanConstructor;
+                required: true;
+            };
+            rotateElement: {
+                type: import('vue').PropType<(element: import('../../../types/slides').PPTTextElement) => void>;
+                required: true;
+            };
+            scaleElement: {
+                type: import('vue').PropType<(e: MouseEvent, element: import('../../../types/slides').PPTTextElement, command: import('../../../types/edit').OperateResizeHandlers) => void>;
+                required: true;
+            };
+        }>, {
+            scaleWidth: import('vue').ComputedRef<number>;
+            textElementResizeHandlers: import('vue').ComputedRef<({
+                direction: import('../../../types/edit').OperateResizeHandlers;
+                style: {
+                    top: string;
+                    left?: undefined;
+                };
+            } | {
+                direction: import('../../../types/edit').OperateResizeHandlers;
+                style: {
+                    left: string;
+                    top: string;
+                };
+            })[]>;
+            borderLines: import('vue').ComputedRef<({
+                type: import('../../../types/edit').OperateBorderLines;
+                style: {
+                    width: string;
+                    top?: undefined;
+                    height?: undefined;
+                    left?: undefined;
+                };
+            } | {
+                type: import('../../../types/edit').OperateBorderLines;
+                style: {
+                    top: string;
+                    width: string;
+                    height?: undefined;
+                    left?: undefined;
+                };
+            } | {
+                type: import('../../../types/edit').OperateBorderLines;
+                style: {
+                    height: string;
+                    width?: undefined;
+                    top?: undefined;
+                    left?: undefined;
+                };
+            } | {
+                type: import('../../../types/edit').OperateBorderLines;
+                style: {
+                    left: string;
+                    height: string;
+                    width?: undefined;
+                    top?: undefined;
+                };
+            })[]>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            elementInfo: {
+                type: import('vue').PropType<import('../../../types/slides').PPTTextElement>;
+                required: true;
+            };
+            handlerVisible: {
+                type: BooleanConstructor;
+                required: true;
+            };
+            rotateElement: {
+                type: import('vue').PropType<(element: import('../../../types/slides').PPTTextElement) => void>;
+                required: true;
+            };
+            scaleElement: {
+                type: import('vue').PropType<(e: MouseEvent, element: import('../../../types/slides').PPTTextElement, command: import('../../../types/edit').OperateResizeHandlers) => void>;
+                required: true;
+            };
+        }>> & Readonly<{}>, {}, {}, {
+            RotateHandler: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            ResizeHandler: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                type: {
+                    type: import('vue').PropType<import('../../../types/edit').OperateResizeHandlers>;
+                    default: string;
+                };
+                rotate: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+            }>, {
+                rotateClassName: import('vue').ComputedRef<string>;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                type: {
+                    type: import('vue').PropType<import('../../../types/edit').OperateResizeHandlers>;
+                    default: string;
+                };
+                rotate: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+            }>> & Readonly<{}>, {
+                rotate: number;
+                type: import('../../../types/edit').OperateResizeHandlers;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            BorderLine: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                type: {
+                    type: import('vue').PropType<import('../../../types/edit').OperateBorderLines>;
+                    required: true;
+                };
+                isWide: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                type: {
+                    type: import('vue').PropType<import('../../../types/edit').OperateBorderLines>;
+                    required: true;
+                };
+                isWide: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                isWide: boolean;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any> | import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            elementInfo: {
+                type: import('vue').PropType<import('../../../types/slides').PPTShapeElement>;
+                required: true;
+            };
+            handlerVisible: {
+                type: BooleanConstructor;
+                required: true;
+            };
+            rotateElement: {
+                type: import('vue').PropType<(element: import('../../../types/slides').PPTShapeElement) => void>;
+                required: true;
+            };
+            scaleElement: {
+                type: import('vue').PropType<(e: MouseEvent, element: import('../../../types/slides').PPTShapeElement, command: import('../../../types/edit').OperateResizeHandlers) => void>;
+                required: true;
+            };
+        }>, {
+            scaleWidth: import('vue').ComputedRef<number>;
+            resizeHandlers: import('vue').ComputedRef<({
+                direction: import('../../../types/edit').OperateResizeHandlers;
+                style: {
+                    left?: undefined;
+                    top?: undefined;
+                };
+            } | {
+                direction: import('../../../types/edit').OperateResizeHandlers;
+                style: {
+                    left: string;
+                    top?: undefined;
+                };
+            } | {
+                direction: import('../../../types/edit').OperateResizeHandlers;
+                style: {
+                    top: string;
+                    left?: undefined;
+                };
+            } | {
+                direction: import('../../../types/edit').OperateResizeHandlers;
+                style: {
+                    left: string;
+                    top: string;
+                };
+            })[]>;
+            borderLines: import('vue').ComputedRef<({
+                type: import('../../../types/edit').OperateBorderLines;
+                style: {
+                    width: string;
+                    top?: undefined;
+                    height?: undefined;
+                    left?: undefined;
+                };
+            } | {
+                type: import('../../../types/edit').OperateBorderLines;
+                style: {
+                    top: string;
+                    width: string;
+                    height?: undefined;
+                    left?: undefined;
+                };
+            } | {
+                type: import('../../../types/edit').OperateBorderLines;
+                style: {
+                    height: string;
+                    width?: undefined;
+                    top?: undefined;
+                    left?: undefined;
+                };
+            } | {
+                type: import('../../../types/edit').OperateBorderLines;
+                style: {
+                    left: string;
+                    height: string;
+                    width?: undefined;
+                    top?: undefined;
+                };
+            })[]>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            elementInfo: {
+                type: import('vue').PropType<import('../../../types/slides').PPTShapeElement>;
+                required: true;
+            };
+            handlerVisible: {
+                type: BooleanConstructor;
+                required: true;
+            };
+            rotateElement: {
+                type: import('vue').PropType<(element: import('../../../types/slides').PPTShapeElement) => void>;
+                required: true;
+            };
+            scaleElement: {
+                type: import('vue').PropType<(e: MouseEvent, element: import('../../../types/slides').PPTShapeElement, command: import('../../../types/edit').OperateResizeHandlers) => void>;
+                required: true;
+            };
+        }>> & Readonly<{}>, {}, {}, {
+            RotateHandler: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            ResizeHandler: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                type: {
+                    type: import('vue').PropType<import('../../../types/edit').OperateResizeHandlers>;
+                    default: string;
+                };
+                rotate: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+            }>, {
+                rotateClassName: import('vue').ComputedRef<string>;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                type: {
+                    type: import('vue').PropType<import('../../../types/edit').OperateResizeHandlers>;
+                    default: string;
+                };
+                rotate: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+            }>> & Readonly<{}>, {
+                rotate: number;
+                type: import('../../../types/edit').OperateResizeHandlers;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            BorderLine: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                type: {
+                    type: import('vue').PropType<import('../../../types/edit').OperateBorderLines>;
+                    required: true;
+                };
+                isWide: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                type: {
+                    type: import('vue').PropType<import('../../../types/edit').OperateBorderLines>;
+                    required: true;
+                };
+                isWide: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                isWide: boolean;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any> | import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            elementInfo: {
+                type: import('vue').PropType<import('../../../types/slides').PPTLineElement>;
+                required: true;
+            };
+            handlerVisible: {
+                type: BooleanConstructor;
+                required: true;
+            };
+            dragLineElement: {
+                type: import('vue').PropType<(e: MouseEvent, element: import('../../../types/slides').PPTLineElement, command: import('../../../types/edit').OperateLineHandlers) => void>;
+                required: true;
+            };
+        }>, {
+            svgWidth: import('vue').ComputedRef<number>;
+            svgHeight: import('vue').ComputedRef<number>;
+            canvasScale: import('vue').Ref<number, number>;
+            resizeHandlers: import('vue').ComputedRef<{
+                handler: import('../../../types/edit').OperateLineHandlers;
+                style: {
+                    left: string;
+                    top: string;
+                };
+            }[]>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            elementInfo: {
+                type: import('vue').PropType<import('../../../types/slides').PPTLineElement>;
+                required: true;
+            };
+            handlerVisible: {
+                type: BooleanConstructor;
+                required: true;
+            };
+            dragLineElement: {
+                type: import('vue').PropType<(e: MouseEvent, element: import('../../../types/slides').PPTLineElement, command: import('../../../types/edit').OperateLineHandlers) => void>;
+                required: true;
+            };
+        }>> & Readonly<{}>, {}, {}, {
+            ResizeHandler: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                type: {
+                    type: import('vue').PropType<import('../../../types/edit').OperateResizeHandlers>;
+                    default: string;
+                };
+                rotate: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+            }>, {
+                rotateClassName: import('vue').ComputedRef<string>;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                type: {
+                    type: import('vue').PropType<import('../../../types/edit').OperateResizeHandlers>;
+                    default: string;
+                };
+                rotate: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+            }>> & Readonly<{}>, {
+                rotate: number;
+                type: import('../../../types/edit').OperateResizeHandlers;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any> | import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            elementInfo: {
+                type: import('vue').PropType<import('../../../types/slides').PPTTableElement>;
+                required: true;
+            };
+            handlerVisible: {
+                type: BooleanConstructor;
+                required: true;
+            };
+            rotateElement: {
+                type: import('vue').PropType<(element: import('../../../types/slides').PPTTableElement) => void>;
+                required: true;
+            };
+            scaleElement: {
+                type: import('vue').PropType<(e: MouseEvent, element: import('../../../types/slides').PPTTableElement, command: import('../../../types/edit').OperateResizeHandlers) => void>;
+                required: true;
+            };
+        }>, {
+            scaleWidth: import('vue').ComputedRef<number>;
+            textElementResizeHandlers: import('vue').ComputedRef<({
+                direction: import('../../../types/edit').OperateResizeHandlers;
+                style: {
+                    top: string;
+                    left?: undefined;
+                };
+            } | {
+                direction: import('../../../types/edit').OperateResizeHandlers;
+                style: {
+                    left: string;
+                    top: string;
+                };
+            })[]>;
+            borderLines: import('vue').ComputedRef<({
+                type: import('../../../types/edit').OperateBorderLines;
+                style: {
+                    width: string;
+                    top?: undefined;
+                    height?: undefined;
+                    left?: undefined;
+                };
+            } | {
+                type: import('../../../types/edit').OperateBorderLines;
+                style: {
+                    top: string;
+                    width: string;
+                    height?: undefined;
+                    left?: undefined;
+                };
+            } | {
+                type: import('../../../types/edit').OperateBorderLines;
+                style: {
+                    height: string;
+                    width?: undefined;
+                    top?: undefined;
+                    left?: undefined;
+                };
+            } | {
+                type: import('../../../types/edit').OperateBorderLines;
+                style: {
+                    left: string;
+                    height: string;
+                    width?: undefined;
+                    top?: undefined;
+                };
+            })[]>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            elementInfo: {
+                type: import('vue').PropType<import('../../../types/slides').PPTTableElement>;
+                required: true;
+            };
+            handlerVisible: {
+                type: BooleanConstructor;
+                required: true;
+            };
+            rotateElement: {
+                type: import('vue').PropType<(element: import('../../../types/slides').PPTTableElement) => void>;
+                required: true;
+            };
+            scaleElement: {
+                type: import('vue').PropType<(e: MouseEvent, element: import('../../../types/slides').PPTTableElement, command: import('../../../types/edit').OperateResizeHandlers) => void>;
+                required: true;
+            };
+        }>> & Readonly<{}>, {}, {}, {
+            RotateHandler: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            ResizeHandler: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                type: {
+                    type: import('vue').PropType<import('../../../types/edit').OperateResizeHandlers>;
+                    default: string;
+                };
+                rotate: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+            }>, {
+                rotateClassName: import('vue').ComputedRef<string>;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                type: {
+                    type: import('vue').PropType<import('../../../types/edit').OperateResizeHandlers>;
+                    default: string;
+                };
+                rotate: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+            }>> & Readonly<{}>, {
+                rotate: number;
+                type: import('../../../types/edit').OperateResizeHandlers;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            BorderLine: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                type: {
+                    type: import('vue').PropType<import('../../../types/edit').OperateBorderLines>;
+                    required: true;
+                };
+                isWide: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                type: {
+                    type: import('vue').PropType<import('../../../types/edit').OperateBorderLines>;
+                    required: true;
+                };
+                isWide: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                isWide: boolean;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any> | import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            elementInfo: {
+                type: import('vue').PropType<import('../../../types/slides').PPTShapeElement | import('../../../types/slides').PPTLatexElement | import('../../../types/slides').PPTVideoElement | import('../../../types/slides').PPTAudioElement>;
+                required: true;
+            };
+            handlerVisible: {
+                type: BooleanConstructor;
+                required: true;
+            };
+            rotateElement: {
+                type: import('vue').PropType<(element: import('../../../types/slides').PPTShapeElement | import('../../../types/slides').PPTLatexElement | import('../../../types/slides').PPTVideoElement | import('../../../types/slides').PPTAudioElement) => void>;
+                required: true;
+            };
+            scaleElement: {
+                type: import('vue').PropType<(e: MouseEvent, element: import('../../../types/slides').PPTShapeElement | import('../../../types/slides').PPTLatexElement | import('../../../types/slides').PPTVideoElement | import('../../../types/slides').PPTAudioElement, command: import('../../../types/edit').OperateResizeHandlers) => void>;
+                required: true;
+            };
+        }>, {
+            scaleWidth: import('vue').ComputedRef<number>;
+            resizeHandlers: import('vue').ComputedRef<({
+                direction: import('../../../types/edit').OperateResizeHandlers;
+                style: {
+                    left?: undefined;
+                    top?: undefined;
+                };
+            } | {
+                direction: import('../../../types/edit').OperateResizeHandlers;
+                style: {
+                    left: string;
+                    top?: undefined;
+                };
+            } | {
+                direction: import('../../../types/edit').OperateResizeHandlers;
+                style: {
+                    top: string;
+                    left?: undefined;
+                };
+            } | {
+                direction: import('../../../types/edit').OperateResizeHandlers;
+                style: {
+                    left: string;
+                    top: string;
+                };
+            })[]>;
+            borderLines: import('vue').ComputedRef<({
+                type: import('../../../types/edit').OperateBorderLines;
+                style: {
+                    width: string;
+                    top?: undefined;
+                    height?: undefined;
+                    left?: undefined;
+                };
+            } | {
+                type: import('../../../types/edit').OperateBorderLines;
+                style: {
+                    top: string;
+                    width: string;
+                    height?: undefined;
+                    left?: undefined;
+                };
+            } | {
+                type: import('../../../types/edit').OperateBorderLines;
+                style: {
+                    height: string;
+                    width?: undefined;
+                    top?: undefined;
+                    left?: undefined;
+                };
+            } | {
+                type: import('../../../types/edit').OperateBorderLines;
+                style: {
+                    left: string;
+                    height: string;
+                    width?: undefined;
+                    top?: undefined;
+                };
+            })[]>;
+            cannotRotate: import('vue').ComputedRef<boolean>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            elementInfo: {
+                type: import('vue').PropType<import('../../../types/slides').PPTShapeElement | import('../../../types/slides').PPTLatexElement | import('../../../types/slides').PPTVideoElement | import('../../../types/slides').PPTAudioElement>;
+                required: true;
+            };
+            handlerVisible: {
+                type: BooleanConstructor;
+                required: true;
+            };
+            rotateElement: {
+                type: import('vue').PropType<(element: import('../../../types/slides').PPTShapeElement | import('../../../types/slides').PPTLatexElement | import('../../../types/slides').PPTVideoElement | import('../../../types/slides').PPTAudioElement) => void>;
+                required: true;
+            };
+            scaleElement: {
+                type: import('vue').PropType<(e: MouseEvent, element: import('../../../types/slides').PPTShapeElement | import('../../../types/slides').PPTLatexElement | import('../../../types/slides').PPTVideoElement | import('../../../types/slides').PPTAudioElement, command: import('../../../types/edit').OperateResizeHandlers) => void>;
+                required: true;
+            };
+        }>> & Readonly<{}>, {}, {}, {
+            RotateHandler: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            ResizeHandler: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                type: {
+                    type: import('vue').PropType<import('../../../types/edit').OperateResizeHandlers>;
+                    default: string;
+                };
+                rotate: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+            }>, {
+                rotateClassName: import('vue').ComputedRef<string>;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                type: {
+                    type: import('vue').PropType<import('../../../types/edit').OperateResizeHandlers>;
+                    default: string;
+                };
+                rotate: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+            }>> & Readonly<{}>, {
+                rotate: number;
+                type: import('../../../types/edit').OperateResizeHandlers;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            BorderLine: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                type: {
+                    type: import('vue').PropType<import('../../../types/edit').OperateBorderLines>;
+                    required: true;
+                };
+                isWide: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                type: {
+                    type: import('vue').PropType<import('../../../types/edit').OperateBorderLines>;
+                    required: true;
+                };
+                isWide: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                isWide: boolean;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>>;
+        canvasScale: import('vue').Ref<number, number>;
+        toolbarState: import('vue').Ref<import('../../../types/toolbar').ToolbarStates, import('../../../types/toolbar').ToolbarStates>;
+        elementIndexListInAnimation: import('vue').ComputedRef<number[]>;
+        rotate: import('vue').ComputedRef<number>;
+        height: import('vue').ComputedRef<number>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        elementInfo: {
+            type: import('vue').PropType<PPTElement>;
+            required: true;
+        };
+        isSelected: {
+            type: BooleanConstructor;
+            required: true;
+        };
+        isActive: {
+            type: BooleanConstructor;
+            required: true;
+        };
+        isActiveGroupElement: {
+            type: BooleanConstructor;
+            required: true;
+        };
+        isMultiSelect: {
+            type: BooleanConstructor;
+            required: true;
+        };
+        rotateElement: {
+            type: import('vue').PropType<(element: Exclude<PPTElement, import('../../../types/slides').PPTLineElement | import('../../../types/slides').PPTVideoElement | import('../../../types/slides').PPTAudioElement>) => void>;
+            required: true;
+        };
+        scaleElement: {
+            type: import('vue').PropType<(e: MouseEvent, element: Exclude<PPTElement, import('../../../types/slides').PPTLineElement>, command: import('../../../types/edit').OperateResizeHandlers) => void>;
+            required: true;
+        };
+        dragLineElement: {
+            type: import('vue').PropType<(e: MouseEvent, element: import('../../../types/slides').PPTLineElement, command: import('../../../types/edit').OperateLineHandlers) => void>;
+            required: true;
+        };
+        openLinkDialog: {
+            type: import('vue').PropType<() => void>;
+            required: true;
+        };
+    }>> & Readonly<{}>, {}, {}, {
+        LinkHandler: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            elementInfo: {
+                type: import('vue').PropType<PPTElement>;
+                required: true;
+            };
+            link: {
+                type: import('vue').PropType<import('../../../types/slides').PPTElementLink>;
+                required: true;
+            };
+            openLinkDialog: {
+                type: import('vue').PropType<() => void>;
+                required: true;
+            };
+        }>, {
+            canvasScale: import('vue').Ref<number, number>;
+            height: import('vue').ComputedRef<number>;
+            removeLink: (handleElement: PPTElement) => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            elementInfo: {
+                type: import('vue').PropType<PPTElement>;
+                required: true;
+            };
+            link: {
+                type: import('vue').PropType<import('../../../types/slides').PPTElementLink>;
+                required: true;
+            };
+            openLinkDialog: {
+                type: import('vue').PropType<() => void>;
+                required: true;
+            };
+        }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    LinkDialog: import('vue').DefineComponent<{}, {
+        slides: import('vue').Ref<import('../../../types/slides').Slide[], import('../../../types/slides').Slide[]>;
+        tabs: import('./LinkDialog.vue').TabItem[];
+        type: import('vue').Ref<"web" | "slide", "web" | "slide">;
+        address: import('vue').Ref<string, string>;
+        slideId: import('vue').Ref<string, string>;
+        selectedSlide: import('vue').ComputedRef<import('../../../types/slides').Slide | null>;
+        close: () => void;
+        save: () => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "close"[], "close", import('vue').PublicProps, Readonly<{}> & Readonly<{
+        onClose?: ((...args: any[]) => any) | undefined;
+    }>, {}, {}, {
+        ThumbnailSlide: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            slide: {
+                type: import('vue').PropType<import('../../../types/slides').Slide>;
+                required: true;
+            };
+            size: {
+                type: NumberConstructor;
+                required: true;
+            };
+            visible: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, {
+            scale: import('vue').ComputedRef<number>;
+            backgroundStyle: import('vue').ComputedRef<{
+                backgroundColor: string | undefined;
+                backgroundImage?: undefined;
+                backgroundRepeat?: undefined;
+                backgroundSize?: undefined;
+            } | {
+                backgroundImage: string;
+                backgroundRepeat: string;
+                backgroundSize: string;
+                backgroundColor?: undefined;
+            } | {
+                backgroundImage: string;
+                backgroundColor?: undefined;
+                backgroundRepeat?: undefined;
+                backgroundSize?: undefined;
+            }>;
+            VIEWPORT_SIZE: number;
+            viewportRatio: import('vue').Ref<number, number>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            slide: {
+                type: import('vue').PropType<import('../../../types/slides').Slide>;
+                required: true;
+            };
+            size: {
+                type: NumberConstructor;
+                required: true;
+            };
+            visible: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{}>, {
+            visible: boolean;
+        }, {}, {
+            ThumbnailElement: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                elementInfo: {
+                    type: import('vue').PropType<PPTElement>;
+                    required: true;
+                };
+                elementIndex: {
+                    type: NumberConstructor;
+                    required: true;
+                };
+            }>, {
+                currentElementComponent: import('vue').ComputedRef<import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                    elementInfo: {
+                        type: import('vue').PropType<import('../../../types/slides').PPTImageElement>;
+                        required: true;
+                    };
+                }>, {
+                    imgPosition: import('vue').ComputedRef<{
+                        top: string;
+                        left: string;
+                        width: string;
+                        height: string;
+                    }>;
+                    filter: import('vue').ComputedRef<string>;
+                    flipStyle: import('vue').ComputedRef<string>;
+                    shadowStyle: import('vue').ComputedRef<string>;
+                    clipShape: import('vue').ComputedRef<any>;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                    elementInfo: {
+                        type: import('vue').PropType<import('../../../types/slides').PPTImageElement>;
+                        required: true;
+                    };
+                }>> & Readonly<{}>, {}, {}, {
+                    ImageOutline: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                        elementInfo: {
+                            type: import('vue').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: import('vue').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: import('vue').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: import('vue').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: import('vue').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: import('vue').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: import('vue').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: import('vue').PropType<import('../../../types/slides').PPTElementOutline>;
+                            };
+                            createPath: {
+                                type: FunctionConstructor;
+                                required: true;
+                            };
+                        }>> & Readonly<{}>, {}, {}, {}, {}, 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: import('vue').PropType<import('../../../types/slides').PPTTextElement>;
+                        required: true;
+                    };
+                }>, {
+                    shadowStyle: import('vue').ComputedRef<string>;
+                    textInsetsPadding: import('vue').ComputedRef<string>;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                    elementInfo: {
+                        type: import('vue').PropType<import('../../../types/slides').PPTTextElement>;
+                        required: true;
+                    };
+                }>> & Readonly<{}>, {}, {}, {
+                    ElementOutline: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                        width: {
+                            type: NumberConstructor;
+                            required: true;
+                        };
+                        height: {
+                            type: NumberConstructor;
+                            required: true;
+                        };
+                        outline: {
+                            type: import('vue').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: import('vue').PropType<import('../../../types/slides').PPTElementOutline>;
+                        };
+                    }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+                }, {}, string, import('vue').ComponentProvideOptions, true, {}, any> | import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                    elementInfo: {
+                        type: import('vue').PropType<import('../../../types/slides').PPTShapeElement>;
+                        required: true;
+                    };
+                }>, {
+                    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>;
+                    text: import('vue').ComputedRef<import('../../../types/slides').ShapeText>;
+                    textInsetsPadding: import('vue').ComputedRef<string>;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                    elementInfo: {
+                        type: import('vue').PropType<import('../../../types/slides').PPTShapeElement>;
+                        required: true;
+                    };
+                }>> & Readonly<{}>, {}, {}, {
+                    GradientDefs: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                        id: {
+                            type: StringConstructor;
+                            required: true;
+                        };
+                        type: {
+                            type: import('vue').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: import('vue').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>;
+                }, {}, string, import('vue').ComponentProvideOptions, true, {}, any> | import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                    elementInfo: {
+                        type: import('vue').PropType<import('../../../types/slides').PPTLineElement>;
+                        required: true;
+                    };
+                }>, {
+                    shadowStyle: import('vue').ComputedRef<string>;
+                    svgWidth: import('vue').ComputedRef<number>;
+                    svgHeight: import('vue').ComputedRef<number>;
+                    lineDashArray: import('vue').ComputedRef<"10, 5" | "0, 0">;
+                    path: import('vue').ComputedRef<string>;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                    elementInfo: {
+                        type: import('vue').PropType<import('../../../types/slides').PPTLineElement>;
+                        required: true;
+                    };
+                }>> & Readonly<{}>, {}, {}, {
+                    LinePointMarker: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                        id: {
+                            type: StringConstructor;
+                            required: true;
+                        };
+                        position: {
+                            type: import('vue').PropType<"start" | "end">;
+                            required: true;
+                        };
+                        type: {
+                            type: import('vue').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: import('vue').PropType<"start" | "end">;
+                            required: true;
+                        };
+                        type: {
+                            type: import('vue').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: import('vue').PropType<import('../../../types/slides').PPTChartElement>;
+                        required: true;
+                    };
+                }>, {
+                    needScaleSize: import('vue').ComputedRef<boolean>;
+                    zoom: import('vue').ComputedRef<number>;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                    elementInfo: {
+                        type: import('vue').PropType<import('../../../types/slides').PPTChartElement>;
+                        required: true;
+                    };
+                }>> & Readonly<{}>, {}, {}, {
+                    ElementOutline: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                        width: {
+                            type: NumberConstructor;
+                            required: true;
+                        };
+                        height: {
+                            type: NumberConstructor;
+                            required: true;
+                        };
+                        outline: {
+                            type: import('vue').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: import('vue').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: import('vue').PropType<import('../../../types/slides').ChartType>;
+                            required: true;
+                        };
+                        data: {
+                            type: import('vue').PropType<import('../../../types/slides').ChartData>;
+                            required: true;
+                        };
+                        options: {
+                            type: import('vue').PropType<import('../../../types/slides').ChartOptions>;
+                        };
+                        themeColor: {
+                            type: import('vue').PropType<string[]>;
+                            required: true;
+                        };
+                        legends: {
+                            type: import('vue').PropType<string[]>;
+                            required: true;
+                        };
+                        gridColor: {
+                            type: StringConstructor;
+                        };
+                        legend: {
+                            type: import('vue').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: import('vue').PropType<import('../../../types/slides').ChartType>;
+                            required: true;
+                        };
+                        data: {
+                            type: import('vue').PropType<import('../../../types/slides').ChartData>;
+                            required: true;
+                        };
+                        options: {
+                            type: import('vue').PropType<import('../../../types/slides').ChartOptions>;
+                        };
+                        themeColor: {
+                            type: import('vue').PropType<string[]>;
+                            required: true;
+                        };
+                        legends: {
+                            type: import('vue').PropType<string[]>;
+                            required: true;
+                        };
+                        gridColor: {
+                            type: StringConstructor;
+                        };
+                        legend: {
+                            type: import('vue').PropType<"" | "top" | "bottom">;
+                        };
+                    }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+                }, {}, string, import('vue').ComponentProvideOptions, true, {}, any> | import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                    elementInfo: {
+                        type: import('vue').PropType<import('../../../types/slides').PPTTableElement>;
+                        required: true;
+                    };
+                }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                    elementInfo: {
+                        type: import('vue').PropType<import('../../../types/slides').PPTTableElement>;
+                        required: true;
+                    };
+                }>> & Readonly<{}>, {}, {}, {
+                    StaticTable: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                        data: {
+                            type: import('vue').PropType<import('../../../types/slides').TableCell[][]>;
+                            required: true;
+                        };
+                        width: {
+                            type: NumberConstructor;
+                            required: true;
+                        };
+                        colWidths: {
+                            type: import('vue').PropType<number[]>;
+                            required: true;
+                        };
+                        outline: {
+                            type: import('vue').PropType<import('../../../types/slides').PPTElementOutline>;
+                            required: true;
+                        };
+                        theme: {
+                            type: import('vue').PropType<import('../../../types/slides').TableTheme>;
+                        };
+                        editable: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                    }>, {
+                        colSizeList: import('vue').Ref<number[], number[]>;
+                        totalWidth: import('vue').ComputedRef<number>;
+                        hideCells: import('vue').ComputedRef<string[]>;
+                        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";
+                        };
+                        formatText: (text: string) => string;
+                        subThemeColor: import('vue').Ref<string[], string[]>;
+                    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                        data: {
+                            type: import('vue').PropType<import('../../../types/slides').TableCell[][]>;
+                            required: true;
+                        };
+                        width: {
+                            type: NumberConstructor;
+                            required: true;
+                        };
+                        colWidths: {
+                            type: import('vue').PropType<number[]>;
+                            required: true;
+                        };
+                        outline: {
+                            type: import('vue').PropType<import('../../../types/slides').PPTElementOutline>;
+                            required: true;
+                        };
+                        theme: {
+                            type: import('vue').PropType<import('../../../types/slides').TableTheme>;
+                        };
+                        editable: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                    }>> & Readonly<{}>, {
+                        editable: boolean;
+                    }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+                }, {}, string, import('vue').ComponentProvideOptions, true, {}, any> | import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                    elementInfo: {
+                        type: import('vue').PropType<import('../../../types/slides').PPTLatexElement>;
+                        required: true;
+                    };
+                }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                    elementInfo: {
+                        type: import('vue').PropType<import('../../../types/slides').PPTLatexElement>;
+                        required: true;
+                    };
+                }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any> | import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                    elementInfo: {
+                        type: import('vue').PropType<import('../../../types/slides').PPTVideoElement>;
+                        required: true;
+                    };
+                }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                    elementInfo: {
+                        type: import('vue').PropType<import('../../../types/slides').PPTVideoElement>;
+                        required: true;
+                    };
+                }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any> | import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                    elementInfo: {
+                        type: import('vue').PropType<import('../../../types/slides').PPTAudioElement>;
+                        required: true;
+                    };
+                }>, {
+                    audioIconSize: import('vue').ComputedRef<string>;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                    elementInfo: {
+                        type: import('vue').PropType<import('../../../types/slides').PPTAudioElement>;
+                        required: true;
+                    };
+                }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>>;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                elementInfo: {
+                    type: import('vue').PropType<PPTElement>;
+                    required: true;
+                };
+                elementIndex: {
+                    type: NumberConstructor;
+                    required: true;
+                };
+            }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=index.vue.d.ts.map