@vervedoc/ppt 1.0.2

package/dist/views/Screen/PresenterView.vue.d.ts

@@ -0,0 +1,2111 @@
+import { PropType } from 'vue';
+import { ContextmenuItem } from '../../components/Contextmenu/types';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    changeViewMode: {
+        type: PropType<(mode: "base" | "presenter") => void>;
+        required: true;
+    };
+}>, {
+    slides: import('vue').Ref<import('../..').Slide[], import('../..').Slide[]>;
+    slideIndex: import('vue').Ref<number, number>;
+    viewportRatio: import('vue').Ref<number, number>;
+    remarkFontSize: import('vue').Ref<number, number>;
+    currentSlideRemark: import('vue').ComputedRef<string>;
+    setRemarkFontSize: (fontSize: number) => void;
+    slideListWrapRef: import('vue').Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    thumbnailsRef: import('vue').Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    slideWidth: import('vue').Ref<number, number>;
+    slideHeight: import('vue').Ref<number, number>;
+    animationIndex: import('vue').Ref<number, number>;
+    turnSlideToId: (id: string) => void;
+    mousewheelListener: import('lodash').DebouncedFuncLeading<(e: WheelEvent) => void>;
+    touchStartListener: (e: TouchEvent) => void;
+    touchEndListener: (e: TouchEvent) => void;
+    turnSlideToIndex: (index: number) => void;
+    contextmenus: () => ContextmenuItem[];
+    slidesLoadLimit: import('vue').Ref<number, number>;
+    handleMousewheelThumbnails: (e: WheelEvent) => void;
+    exitScreening: () => void;
+    fullscreenState: import('vue').Ref<boolean, boolean>;
+    enterFullscreen: () => void;
+    manualExitFullscreen: () => void;
+    writingBoardToolVisible: import('vue').Ref<boolean, boolean>;
+    laserPen: import('vue').Ref<boolean, boolean>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    changeViewMode: {
+        type: PropType<(mode: "base" | "presenter") => void>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {
+    ScreenSlideList: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        slideWidth: {
+            type: NumberConstructor;
+            required: true;
+        };
+        slideHeight: {
+            type: NumberConstructor;
+            required: true;
+        };
+        animationIndex: {
+            type: NumberConstructor;
+            required: true;
+        };
+        turnSlideToId: {
+            type: PropType<(id: string) => void>;
+            required: true;
+        };
+        manualExitFullscreen: {
+            type: PropType<() => void>;
+            required: true;
+        };
+    }>, {
+        slides: import('vue').Ref<import('../..').Slide[], import('../..').Slide[]>;
+        slideIndex: import('vue').Ref<number, number>;
+        currentSlide: import('vue').ComputedRef<{
+            id: string;
+            elements: ({
+                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;
+            })[];
+            remark?: string | undefined;
+            background?: {
+                type: "solid" | "image" | "gradient";
+                color?: string | undefined;
+                image?: string | undefined;
+                imageSize?: ("cover" | "contain" | "repeat") | undefined;
+                gradientType?: ("linear" | "radial") | undefined;
+                gradientColor?: [string, string] | undefined;
+                gradientRotate?: number | undefined;
+            } | undefined;
+            animations?: {
+                id: string;
+                elId: string;
+                effect: string;
+                type: "in" | "out" | "attention";
+                duration: number;
+                trigger: "click" | "meantime" | "auto";
+            }[] | undefined;
+            turningMode?: import('../../types/slides').TurningMode | undefined;
+        }>;
+        scale: import('vue').ComputedRef<number>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        slideWidth: {
+            type: NumberConstructor;
+            required: true;
+        };
+        slideHeight: {
+            type: NumberConstructor;
+            required: true;
+        };
+        animationIndex: {
+            type: NumberConstructor;
+            required: true;
+        };
+        turnSlideToId: {
+            type: PropType<(id: string) => void>;
+            required: true;
+        };
+        manualExitFullscreen: {
+            type: PropType<() => void>;
+            required: true;
+        };
+    }>> & Readonly<{}>, {}, {}, {
+        ScreenSlide: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            slide: {
+                type: PropType<import('../..').Slide>;
+                required: true;
+            };
+            scale: {
+                type: NumberConstructor;
+                required: true;
+            };
+            animationIndex: {
+                type: NumberConstructor;
+                required: true;
+            };
+            turnSlideToId: {
+                type: PropType<(id: string) => void>;
+                required: true;
+            };
+            manualExitFullscreen: {
+                type: PropType<() => void>;
+                required: true;
+            };
+        }>, {
+            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: PropType<import('../..').Slide>;
+                required: true;
+            };
+            scale: {
+                type: NumberConstructor;
+                required: true;
+            };
+            animationIndex: {
+                type: NumberConstructor;
+                required: true;
+            };
+            turnSlideToId: {
+                type: PropType<(id: string) => void>;
+                required: true;
+            };
+            manualExitFullscreen: {
+                type: PropType<() => void>;
+                required: true;
+            };
+        }>> & Readonly<{}>, {}, {}, {
+            ScreenElement: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                elementInfo: {
+                    type: PropType<import('../..').PPTElement>;
+                    required: true;
+                };
+                elementIndex: {
+                    type: NumberConstructor;
+                    required: true;
+                };
+                animationIndex: {
+                    type: NumberConstructor;
+                    required: true;
+                };
+                turnSlideToId: {
+                    type: PropType<(id: string) => void>;
+                    required: true;
+                };
+                manualExitFullscreen: {
+                    type: PropType<() => void>;
+                    required: true;
+                };
+            }>, {
+                currentElementComponent: import('vue').ComputedRef<import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                    elementInfo: {
+                        type: PropType<import('../..').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: PropType<import('../..').PPTImageElement>;
+                        required: true;
+                    };
+                }>> & Readonly<{}>, {}, {}, {
+                    ImageOutline: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                        elementInfo: {
+                            type: PropType<import('../..').PPTImageElement>;
+                            required: true;
+                        };
+                    }>, {
+                        clipShape: import('vue').ComputedRef<any>;
+                    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                        elementInfo: {
+                            type: PropType<import('../..').PPTImageElement>;
+                            required: true;
+                        };
+                    }>> & Readonly<{}>, {}, {}, {
+                        ImageRectOutline: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                            width: {
+                                type: NumberConstructor;
+                                required: true;
+                            };
+                            height: {
+                                type: NumberConstructor;
+                                required: true;
+                            };
+                            outline: {
+                                type: PropType<import('../../types/slides').PPTElementOutline>;
+                            };
+                            radius: {
+                                type: StringConstructor;
+                                default: string;
+                            };
+                        }>, {
+                            outlineWidth: import('vue').ComputedRef<number>;
+                            outlineStyle: import('vue').ComputedRef<"dashed" | "solid">;
+                            outlineColor: import('vue').ComputedRef<string>;
+                        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                            width: {
+                                type: NumberConstructor;
+                                required: true;
+                            };
+                            height: {
+                                type: NumberConstructor;
+                                required: true;
+                            };
+                            outline: {
+                                type: PropType<import('../../types/slides').PPTElementOutline>;
+                            };
+                            radius: {
+                                type: StringConstructor;
+                                default: string;
+                            };
+                        }>> & Readonly<{}>, {
+                            radius: string;
+                        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+                        ImageEllipseOutline: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                            width: {
+                                type: NumberConstructor;
+                                required: true;
+                            };
+                            height: {
+                                type: NumberConstructor;
+                                required: true;
+                            };
+                            outline: {
+                                type: PropType<import('../../types/slides').PPTElementOutline>;
+                            };
+                        }>, {
+                            outlineWidth: import('vue').ComputedRef<number>;
+                            outlineStyle: import('vue').ComputedRef<"dashed" | "solid">;
+                            outlineColor: import('vue').ComputedRef<string>;
+                        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                            width: {
+                                type: NumberConstructor;
+                                required: true;
+                            };
+                            height: {
+                                type: NumberConstructor;
+                                required: true;
+                            };
+                            outline: {
+                                type: PropType<import('../../types/slides').PPTElementOutline>;
+                            };
+                        }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+                        ImagePolygonOutline: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                            width: {
+                                type: NumberConstructor;
+                                required: true;
+                            };
+                            height: {
+                                type: NumberConstructor;
+                                required: true;
+                            };
+                            outline: {
+                                type: PropType<import('../../types/slides').PPTElementOutline>;
+                            };
+                            createPath: {
+                                type: FunctionConstructor;
+                                required: true;
+                            };
+                        }>, {
+                            outlineWidth: import('vue').ComputedRef<number>;
+                            outlineStyle: import('vue').ComputedRef<"dashed" | "solid">;
+                            outlineColor: import('vue').ComputedRef<string>;
+                        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                            width: {
+                                type: NumberConstructor;
+                                required: true;
+                            };
+                            height: {
+                                type: NumberConstructor;
+                                required: true;
+                            };
+                            outline: {
+                                type: PropType<import('../../types/slides').PPTElementOutline>;
+                            };
+                            createPath: {
+                                type: FunctionConstructor;
+                                required: true;
+                            };
+                        }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+                    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+                }, {}, string, import('vue').ComponentProvideOptions, true, {}, any> | import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                    elementInfo: {
+                        type: PropType<import('../..').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: PropType<import('../..').PPTTextElement>;
+                        required: true;
+                    };
+                }>> & Readonly<{}>, {}, {}, {
+                    ElementOutline: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                        width: {
+                            type: NumberConstructor;
+                            required: true;
+                        };
+                        height: {
+                            type: NumberConstructor;
+                            required: true;
+                        };
+                        outline: {
+                            type: PropType<import('../../types/slides').PPTElementOutline>;
+                        };
+                    }>, {
+                        outlineWidth: import('vue').ComputedRef<number>;
+                        outlineStyle: import('vue').ComputedRef<"dashed" | "solid">;
+                        outlineColor: import('vue').ComputedRef<string>;
+                    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                        width: {
+                            type: NumberConstructor;
+                            required: true;
+                        };
+                        height: {
+                            type: NumberConstructor;
+                            required: true;
+                        };
+                        outline: {
+                            type: PropType<import('../../types/slides').PPTElementOutline>;
+                        };
+                    }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+                }, {}, string, import('vue').ComponentProvideOptions, true, {}, any> | import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                    elementInfo: {
+                        type: PropType<import('../..').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: PropType<import('../..').PPTShapeElement>;
+                        required: true;
+                    };
+                }>> & Readonly<{}>, {}, {}, {
+                    GradientDefs: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                        id: {
+                            type: StringConstructor;
+                            required: true;
+                        };
+                        type: {
+                            type: PropType<"linear" | "radial">;
+                        };
+                        color1: {
+                            type: StringConstructor;
+                            required: true;
+                        };
+                        color2: {
+                            type: StringConstructor;
+                            required: true;
+                        };
+                        rotate: {
+                            type: NumberConstructor;
+                            default: number;
+                        };
+                    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                        id: {
+                            type: StringConstructor;
+                            required: true;
+                        };
+                        type: {
+                            type: PropType<"linear" | "radial">;
+                        };
+                        color1: {
+                            type: StringConstructor;
+                            required: true;
+                        };
+                        color2: {
+                            type: StringConstructor;
+                            required: true;
+                        };
+                        rotate: {
+                            type: NumberConstructor;
+                            default: number;
+                        };
+                    }>> & Readonly<{}>, {
+                        rotate: number;
+                    }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+                }, {}, string, import('vue').ComponentProvideOptions, true, {}, any> | import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                    elementInfo: {
+                        type: PropType<import('../..').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: PropType<import('../..').PPTLineElement>;
+                        required: true;
+                    };
+                }>> & Readonly<{}>, {}, {}, {
+                    LinePointMarker: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                        id: {
+                            type: StringConstructor;
+                            required: true;
+                        };
+                        position: {
+                            type: PropType<"start" | "end">;
+                            required: true;
+                        };
+                        type: {
+                            type: PropType<"dot" | "arrow">;
+                            required: true;
+                        };
+                        color: {
+                            type: StringConstructor;
+                        };
+                        baseSize: {
+                            type: NumberConstructor;
+                            required: true;
+                        };
+                    }>, {
+                        path: import('vue').ComputedRef<string>;
+                        rotate: import('vue').ComputedRef<number>;
+                        size: import('vue').ComputedRef<number>;
+                    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                        id: {
+                            type: StringConstructor;
+                            required: true;
+                        };
+                        position: {
+                            type: PropType<"start" | "end">;
+                            required: true;
+                        };
+                        type: {
+                            type: PropType<"dot" | "arrow">;
+                            required: true;
+                        };
+                        color: {
+                            type: StringConstructor;
+                        };
+                        baseSize: {
+                            type: NumberConstructor;
+                            required: true;
+                        };
+                    }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+                }, {}, string, import('vue').ComponentProvideOptions, true, {}, any> | import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                    elementInfo: {
+                        type: PropType<import('../..').PPTTableElement>;
+                        required: true;
+                    };
+                }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                    elementInfo: {
+                        type: PropType<import('../..').PPTTableElement>;
+                        required: true;
+                    };
+                }>> & Readonly<{}>, {}, {}, {
+                    StaticTable: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                        data: {
+                            type: PropType<import('../../types/slides').TableCell[][]>;
+                            required: true;
+                        };
+                        width: {
+                            type: NumberConstructor;
+                            required: true;
+                        };
+                        colWidths: {
+                            type: PropType<number[]>;
+                            required: true;
+                        };
+                        outline: {
+                            type: PropType<import('../../types/slides').PPTElementOutline>;
+                            required: true;
+                        };
+                        theme: {
+                            type: PropType<import('../../types/slides').TableTheme>;
+                        };
+                        editable: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                    }>, {
+                        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: PropType<import('../../types/slides').TableCell[][]>;
+                            required: true;
+                        };
+                        width: {
+                            type: NumberConstructor;
+                            required: true;
+                        };
+                        colWidths: {
+                            type: PropType<number[]>;
+                            required: true;
+                        };
+                        outline: {
+                            type: PropType<import('../../types/slides').PPTElementOutline>;
+                            required: true;
+                        };
+                        theme: {
+                            type: PropType<import('../../types/slides').TableTheme>;
+                        };
+                        editable: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                    }>> & Readonly<{}>, {
+                        editable: boolean;
+                    }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+                }, {}, string, import('vue').ComponentProvideOptions, true, {}, any> | import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                    elementInfo: {
+                        type: PropType<import('../..').PPTLatexElement>;
+                        required: true;
+                    };
+                }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                    elementInfo: {
+                        type: PropType<import('../..').PPTLatexElement>;
+                        required: true;
+                    };
+                }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any> | import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                    elementInfo: {
+                        type: PropType<import('../..').PPTChartElement>;
+                        required: true;
+                    };
+                }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                    elementInfo: {
+                        type: PropType<import('../..').PPTChartElement>;
+                        required: true;
+                    };
+                }>> & Readonly<{}>, {}, {}, {
+                    BaseChartElement: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                        elementInfo: {
+                            type: PropType<import('../..').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: PropType<import('../..').PPTChartElement>;
+                            required: true;
+                        };
+                    }>> & Readonly<{}>, {}, {}, {
+                        ElementOutline: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                            width: {
+                                type: NumberConstructor;
+                                required: true;
+                            };
+                            height: {
+                                type: NumberConstructor;
+                                required: true;
+                            };
+                            outline: {
+                                type: PropType<import('../../types/slides').PPTElementOutline>;
+                            };
+                        }>, {
+                            outlineWidth: import('vue').ComputedRef<number>;
+                            outlineStyle: import('vue').ComputedRef<"dashed" | "solid">;
+                            outlineColor: import('vue').ComputedRef<string>;
+                        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                            width: {
+                                type: NumberConstructor;
+                                required: true;
+                            };
+                            height: {
+                                type: NumberConstructor;
+                                required: true;
+                            };
+                            outline: {
+                                type: PropType<import('../../types/slides').PPTElementOutline>;
+                            };
+                        }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+                        Chart: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                            width: {
+                                type: NumberConstructor;
+                                required: true;
+                            };
+                            height: {
+                                type: NumberConstructor;
+                                required: true;
+                            };
+                            type: {
+                                type: PropType<import('../../types/slides').ChartType>;
+                                required: true;
+                            };
+                            data: {
+                                type: PropType<import('../../types/slides').ChartData>;
+                                required: true;
+                            };
+                            options: {
+                                type: PropType<import('../../types/slides').ChartOptions>;
+                            };
+                            themeColor: {
+                                type: PropType<string[]>;
+                                required: true;
+                            };
+                            legends: {
+                                type: PropType<string[]>;
+                                required: true;
+                            };
+                            gridColor: {
+                                type: StringConstructor;
+                            };
+                            legend: {
+                                type: PropType<"" | "top" | "bottom">;
+                            };
+                        }>, {
+                            chartHeight: import('vue').ComputedRef<number>;
+                            themeColors: import('vue').ComputedRef<string[]>;
+                            slideScale: import('vue').Ref<number, number>;
+                            chartRef: import('vue').Ref<HTMLElement | undefined, HTMLElement | undefined>;
+                        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                            width: {
+                                type: NumberConstructor;
+                                required: true;
+                            };
+                            height: {
+                                type: NumberConstructor;
+                                required: true;
+                            };
+                            type: {
+                                type: PropType<import('../../types/slides').ChartType>;
+                                required: true;
+                            };
+                            data: {
+                                type: PropType<import('../../types/slides').ChartData>;
+                                required: true;
+                            };
+                            options: {
+                                type: PropType<import('../../types/slides').ChartOptions>;
+                            };
+                            themeColor: {
+                                type: PropType<string[]>;
+                                required: true;
+                            };
+                            legends: {
+                                type: PropType<string[]>;
+                                required: true;
+                            };
+                            gridColor: {
+                                type: StringConstructor;
+                            };
+                            legend: {
+                                type: PropType<"" | "top" | "bottom">;
+                            };
+                        }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+                    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+                }, {}, string, import('vue').ComponentProvideOptions, true, {}, any> | import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                    elementInfo: {
+                        type: PropType<import('../..').PPTVideoElement>;
+                        required: true;
+                    };
+                }>, {
+                    scale: import('vue').Ref<number, number>;
+                    inCurrentSlide: import('vue').ComputedRef<boolean>;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                    elementInfo: {
+                        type: PropType<import('../..').PPTVideoElement>;
+                        required: true;
+                    };
+                }>> & Readonly<{}>, {}, {}, {
+                    VideoPlayer: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                        width: {
+                            type: NumberConstructor;
+                            required: true;
+                        };
+                        height: {
+                            type: NumberConstructor;
+                            required: true;
+                        };
+                        src: {
+                            type: StringConstructor;
+                            required: true;
+                        };
+                        poster: {
+                            type: StringConstructor;
+                            default: string;
+                        };
+                        scale: {
+                            type: NumberConstructor;
+                            default: number;
+                        };
+                    }>, {
+                        videoRef: import('vue').Ref<HTMLVideoElement | undefined, HTMLVideoElement | undefined>;
+                        playBarWrap: import('vue').Ref<HTMLElement | undefined, HTMLElement | undefined>;
+                        volumeBarRef: import('vue').Ref<HTMLElement | undefined, HTMLElement | undefined>;
+                        volume: import('vue').Ref<number, number>;
+                        loop: import('vue').Ref<boolean, boolean>;
+                        paused: import('vue').Ref<boolean, boolean>;
+                        ptime: import('vue').ComputedRef<string>;
+                        dtime: import('vue').ComputedRef<string>;
+                        playBarTime: import('vue').Ref<string, string>;
+                        playBarTimeVisible: import('vue').Ref<boolean, boolean>;
+                        playBarTimeLeft: import('vue').Ref<string, string>;
+                        playedBarWidth: import('vue').ComputedRef<string>;
+                        loadedBarWidth: import('vue').ComputedRef<string>;
+                        volumeBarWidth: import('vue').ComputedRef<string>;
+                        hideController: import('vue').Ref<boolean, boolean>;
+                        bezelTransition: import('vue').Ref<boolean, boolean>;
+                        playbackRate: import('vue').Ref<number, number>;
+                        speedMenuVisible: import('vue').Ref<boolean, boolean>;
+                        speedOptions: {
+                            label: string;
+                            value: number;
+                        }[];
+                        seek: (time: number) => void;
+                        play: () => void;
+                        pause: () => void;
+                        toggle: () => void;
+                        setVolume: (percentage: number) => void;
+                        speed: (rate: number) => void;
+                        handleDurationchange: () => void;
+                        handleTimeupdate: () => void;
+                        handleEnded: () => void;
+                        handleProgress: () => void;
+                        handleMousedownPlayBar: () => void;
+                        handleMousedownVolumeBar: () => void;
+                        handleClickVolumeBar: (e: MouseEvent) => void;
+                        handleMousemovePlayBar: (e: MouseEvent) => void;
+                        toggleVolume: () => void;
+                        toggleLoop: () => void;
+                        autoHideController: () => void;
+                        handleError: () => import('element-plus').MessageHandler;
+                    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                        width: {
+                            type: NumberConstructor;
+                            required: true;
+                        };
+                        height: {
+                            type: NumberConstructor;
+                            required: true;
+                        };
+                        src: {
+                            type: StringConstructor;
+                            required: true;
+                        };
+                        poster: {
+                            type: StringConstructor;
+                            default: string;
+                        };
+                        scale: {
+                            type: NumberConstructor;
+                            default: number;
+                        };
+                    }>> & Readonly<{}>, {
+                        poster: string;
+                        scale: number;
+                    }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+                }, {}, string, import('vue').ComponentProvideOptions, true, {}, any> | import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                    elementInfo: {
+                        type: PropType<import('../..').PPTAudioElement>;
+                        required: true;
+                    };
+                }>, {
+                    scale: import('vue').Ref<number, number>;
+                    inCurrentSlide: import('vue').ComputedRef<boolean>;
+                    audioIconSize: import('vue').ComputedRef<string>;
+                    audioPlayerPosition: import('vue').ComputedRef<{
+                        left: string;
+                        top: string;
+                    }>;
+                    audioPlayerRef: import('vue').Ref<any, any>;
+                    toggle: () => void;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                    elementInfo: {
+                        type: PropType<import('../..').PPTAudioElement>;
+                        required: true;
+                    };
+                }>> & 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>>;
+                needWaitAnimation: import('vue').ComputedRef<boolean>;
+                theme: import('vue').Ref<import('../..').SlideTheme, import('../..').SlideTheme>;
+                openLink: () => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                elementInfo: {
+                    type: PropType<import('../..').PPTElement>;
+                    required: true;
+                };
+                elementIndex: {
+                    type: NumberConstructor;
+                    required: true;
+                };
+                animationIndex: {
+                    type: NumberConstructor;
+                    required: true;
+                };
+                turnSlideToId: {
+                    type: PropType<(id: string) => void>;
+                    required: true;
+                };
+                manualExitFullscreen: {
+                    type: PropType<() => void>;
+                    required: true;
+                };
+            }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    ThumbnailSlide: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        slide: {
+            type: PropType<import('../..').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: PropType<import('../..').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: PropType<import('../..').PPTElement>;
+                required: true;
+            };
+            elementIndex: {
+                type: NumberConstructor;
+                required: true;
+            };
+        }>, {
+            currentElementComponent: import('vue').ComputedRef<import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                elementInfo: {
+                    type: PropType<import('../..').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: PropType<import('../..').PPTImageElement>;
+                    required: true;
+                };
+            }>> & Readonly<{}>, {}, {}, {
+                ImageOutline: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                    elementInfo: {
+                        type: PropType<import('../..').PPTImageElement>;
+                        required: true;
+                    };
+                }>, {
+                    clipShape: import('vue').ComputedRef<any>;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                    elementInfo: {
+                        type: PropType<import('../..').PPTImageElement>;
+                        required: true;
+                    };
+                }>> & Readonly<{}>, {}, {}, {
+                    ImageRectOutline: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                        width: {
+                            type: NumberConstructor;
+                            required: true;
+                        };
+                        height: {
+                            type: NumberConstructor;
+                            required: true;
+                        };
+                        outline: {
+                            type: PropType<import('../../types/slides').PPTElementOutline>;
+                        };
+                        radius: {
+                            type: StringConstructor;
+                            default: string;
+                        };
+                    }>, {
+                        outlineWidth: import('vue').ComputedRef<number>;
+                        outlineStyle: import('vue').ComputedRef<"dashed" | "solid">;
+                        outlineColor: import('vue').ComputedRef<string>;
+                    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                        width: {
+                            type: NumberConstructor;
+                            required: true;
+                        };
+                        height: {
+                            type: NumberConstructor;
+                            required: true;
+                        };
+                        outline: {
+                            type: PropType<import('../../types/slides').PPTElementOutline>;
+                        };
+                        radius: {
+                            type: StringConstructor;
+                            default: string;
+                        };
+                    }>> & Readonly<{}>, {
+                        radius: string;
+                    }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+                    ImageEllipseOutline: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                        width: {
+                            type: NumberConstructor;
+                            required: true;
+                        };
+                        height: {
+                            type: NumberConstructor;
+                            required: true;
+                        };
+                        outline: {
+                            type: PropType<import('../../types/slides').PPTElementOutline>;
+                        };
+                    }>, {
+                        outlineWidth: import('vue').ComputedRef<number>;
+                        outlineStyle: import('vue').ComputedRef<"dashed" | "solid">;
+                        outlineColor: import('vue').ComputedRef<string>;
+                    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                        width: {
+                            type: NumberConstructor;
+                            required: true;
+                        };
+                        height: {
+                            type: NumberConstructor;
+                            required: true;
+                        };
+                        outline: {
+                            type: PropType<import('../../types/slides').PPTElementOutline>;
+                        };
+                    }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+                    ImagePolygonOutline: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                        width: {
+                            type: NumberConstructor;
+                            required: true;
+                        };
+                        height: {
+                            type: NumberConstructor;
+                            required: true;
+                        };
+                        outline: {
+                            type: PropType<import('../../types/slides').PPTElementOutline>;
+                        };
+                        createPath: {
+                            type: FunctionConstructor;
+                            required: true;
+                        };
+                    }>, {
+                        outlineWidth: import('vue').ComputedRef<number>;
+                        outlineStyle: import('vue').ComputedRef<"dashed" | "solid">;
+                        outlineColor: import('vue').ComputedRef<string>;
+                    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                        width: {
+                            type: NumberConstructor;
+                            required: true;
+                        };
+                        height: {
+                            type: NumberConstructor;
+                            required: true;
+                        };
+                        outline: {
+                            type: PropType<import('../../types/slides').PPTElementOutline>;
+                        };
+                        createPath: {
+                            type: FunctionConstructor;
+                            required: true;
+                        };
+                    }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+                }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            }, {}, string, import('vue').ComponentProvideOptions, true, {}, any> | import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                elementInfo: {
+                    type: PropType<import('../..').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: PropType<import('../..').PPTTextElement>;
+                    required: true;
+                };
+            }>> & Readonly<{}>, {}, {}, {
+                ElementOutline: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                    width: {
+                        type: NumberConstructor;
+                        required: true;
+                    };
+                    height: {
+                        type: NumberConstructor;
+                        required: true;
+                    };
+                    outline: {
+                        type: PropType<import('../../types/slides').PPTElementOutline>;
+                    };
+                }>, {
+                    outlineWidth: import('vue').ComputedRef<number>;
+                    outlineStyle: import('vue').ComputedRef<"dashed" | "solid">;
+                    outlineColor: import('vue').ComputedRef<string>;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                    width: {
+                        type: NumberConstructor;
+                        required: true;
+                    };
+                    height: {
+                        type: NumberConstructor;
+                        required: true;
+                    };
+                    outline: {
+                        type: PropType<import('../../types/slides').PPTElementOutline>;
+                    };
+                }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            }, {}, string, import('vue').ComponentProvideOptions, true, {}, any> | import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                elementInfo: {
+                    type: PropType<import('../..').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: PropType<import('../..').PPTShapeElement>;
+                    required: true;
+                };
+            }>> & Readonly<{}>, {}, {}, {
+                GradientDefs: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                    id: {
+                        type: StringConstructor;
+                        required: true;
+                    };
+                    type: {
+                        type: PropType<"linear" | "radial">;
+                    };
+                    color1: {
+                        type: StringConstructor;
+                        required: true;
+                    };
+                    color2: {
+                        type: StringConstructor;
+                        required: true;
+                    };
+                    rotate: {
+                        type: NumberConstructor;
+                        default: number;
+                    };
+                }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                    id: {
+                        type: StringConstructor;
+                        required: true;
+                    };
+                    type: {
+                        type: PropType<"linear" | "radial">;
+                    };
+                    color1: {
+                        type: StringConstructor;
+                        required: true;
+                    };
+                    color2: {
+                        type: StringConstructor;
+                        required: true;
+                    };
+                    rotate: {
+                        type: NumberConstructor;
+                        default: number;
+                    };
+                }>> & Readonly<{}>, {
+                    rotate: number;
+                }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            }, {}, string, import('vue').ComponentProvideOptions, true, {}, any> | import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                elementInfo: {
+                    type: PropType<import('../..').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: PropType<import('../..').PPTLineElement>;
+                    required: true;
+                };
+            }>> & Readonly<{}>, {}, {}, {
+                LinePointMarker: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                    id: {
+                        type: StringConstructor;
+                        required: true;
+                    };
+                    position: {
+                        type: PropType<"start" | "end">;
+                        required: true;
+                    };
+                    type: {
+                        type: PropType<"dot" | "arrow">;
+                        required: true;
+                    };
+                    color: {
+                        type: StringConstructor;
+                    };
+                    baseSize: {
+                        type: NumberConstructor;
+                        required: true;
+                    };
+                }>, {
+                    path: import('vue').ComputedRef<string>;
+                    rotate: import('vue').ComputedRef<number>;
+                    size: import('vue').ComputedRef<number>;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                    id: {
+                        type: StringConstructor;
+                        required: true;
+                    };
+                    position: {
+                        type: PropType<"start" | "end">;
+                        required: true;
+                    };
+                    type: {
+                        type: PropType<"dot" | "arrow">;
+                        required: true;
+                    };
+                    color: {
+                        type: StringConstructor;
+                    };
+                    baseSize: {
+                        type: NumberConstructor;
+                        required: true;
+                    };
+                }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            }, {}, string, import('vue').ComponentProvideOptions, true, {}, any> | import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                elementInfo: {
+                    type: PropType<import('../..').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: PropType<import('../..').PPTChartElement>;
+                    required: true;
+                };
+            }>> & Readonly<{}>, {}, {}, {
+                ElementOutline: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                    width: {
+                        type: NumberConstructor;
+                        required: true;
+                    };
+                    height: {
+                        type: NumberConstructor;
+                        required: true;
+                    };
+                    outline: {
+                        type: PropType<import('../../types/slides').PPTElementOutline>;
+                    };
+                }>, {
+                    outlineWidth: import('vue').ComputedRef<number>;
+                    outlineStyle: import('vue').ComputedRef<"dashed" | "solid">;
+                    outlineColor: import('vue').ComputedRef<string>;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                    width: {
+                        type: NumberConstructor;
+                        required: true;
+                    };
+                    height: {
+                        type: NumberConstructor;
+                        required: true;
+                    };
+                    outline: {
+                        type: PropType<import('../../types/slides').PPTElementOutline>;
+                    };
+                }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+                Chart: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                    width: {
+                        type: NumberConstructor;
+                        required: true;
+                    };
+                    height: {
+                        type: NumberConstructor;
+                        required: true;
+                    };
+                    type: {
+                        type: PropType<import('../../types/slides').ChartType>;
+                        required: true;
+                    };
+                    data: {
+                        type: PropType<import('../../types/slides').ChartData>;
+                        required: true;
+                    };
+                    options: {
+                        type: PropType<import('../../types/slides').ChartOptions>;
+                    };
+                    themeColor: {
+                        type: PropType<string[]>;
+                        required: true;
+                    };
+                    legends: {
+                        type: PropType<string[]>;
+                        required: true;
+                    };
+                    gridColor: {
+                        type: StringConstructor;
+                    };
+                    legend: {
+                        type: PropType<"" | "top" | "bottom">;
+                    };
+                }>, {
+                    chartHeight: import('vue').ComputedRef<number>;
+                    themeColors: import('vue').ComputedRef<string[]>;
+                    slideScale: import('vue').Ref<number, number>;
+                    chartRef: import('vue').Ref<HTMLElement | undefined, HTMLElement | undefined>;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                    width: {
+                        type: NumberConstructor;
+                        required: true;
+                    };
+                    height: {
+                        type: NumberConstructor;
+                        required: true;
+                    };
+                    type: {
+                        type: PropType<import('../../types/slides').ChartType>;
+                        required: true;
+                    };
+                    data: {
+                        type: PropType<import('../../types/slides').ChartData>;
+                        required: true;
+                    };
+                    options: {
+                        type: PropType<import('../../types/slides').ChartOptions>;
+                    };
+                    themeColor: {
+                        type: PropType<string[]>;
+                        required: true;
+                    };
+                    legends: {
+                        type: PropType<string[]>;
+                        required: true;
+                    };
+                    gridColor: {
+                        type: StringConstructor;
+                    };
+                    legend: {
+                        type: PropType<"" | "top" | "bottom">;
+                    };
+                }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            }, {}, string, import('vue').ComponentProvideOptions, true, {}, any> | import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                elementInfo: {
+                    type: PropType<import('../..').PPTTableElement>;
+                    required: true;
+                };
+            }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                elementInfo: {
+                    type: PropType<import('../..').PPTTableElement>;
+                    required: true;
+                };
+            }>> & Readonly<{}>, {}, {}, {
+                StaticTable: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                    data: {
+                        type: PropType<import('../../types/slides').TableCell[][]>;
+                        required: true;
+                    };
+                    width: {
+                        type: NumberConstructor;
+                        required: true;
+                    };
+                    colWidths: {
+                        type: PropType<number[]>;
+                        required: true;
+                    };
+                    outline: {
+                        type: PropType<import('../../types/slides').PPTElementOutline>;
+                        required: true;
+                    };
+                    theme: {
+                        type: PropType<import('../../types/slides').TableTheme>;
+                    };
+                    editable: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>, {
+                    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: PropType<import('../../types/slides').TableCell[][]>;
+                        required: true;
+                    };
+                    width: {
+                        type: NumberConstructor;
+                        required: true;
+                    };
+                    colWidths: {
+                        type: PropType<number[]>;
+                        required: true;
+                    };
+                    outline: {
+                        type: PropType<import('../../types/slides').PPTElementOutline>;
+                        required: true;
+                    };
+                    theme: {
+                        type: PropType<import('../../types/slides').TableTheme>;
+                    };
+                    editable: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>> & Readonly<{}>, {
+                    editable: boolean;
+                }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            }, {}, string, import('vue').ComponentProvideOptions, true, {}, any> | import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                elementInfo: {
+                    type: PropType<import('../..').PPTLatexElement>;
+                    required: true;
+                };
+            }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                elementInfo: {
+                    type: PropType<import('../..').PPTLatexElement>;
+                    required: true;
+                };
+            }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any> | import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                elementInfo: {
+                    type: PropType<import('../..').PPTVideoElement>;
+                    required: true;
+                };
+            }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                elementInfo: {
+                    type: PropType<import('../..').PPTVideoElement>;
+                    required: true;
+                };
+            }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any> | import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                elementInfo: {
+                    type: PropType<import('../..').PPTAudioElement>;
+                    required: true;
+                };
+            }>, {
+                audioIconSize: import('vue').ComputedRef<string>;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                elementInfo: {
+                    type: PropType<import('../..').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: PropType<import('../..').PPTElement>;
+                required: true;
+            };
+            elementIndex: {
+                type: NumberConstructor;
+                required: true;
+            };
+        }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    WritingBoardTool: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        slideWidth: {
+            type: NumberConstructor;
+            required: true;
+        };
+        slideHeight: {
+            type: NumberConstructor;
+            required: true;
+        };
+        position: {
+            type: PropType<import('./WritingBoardTool.vue').Position>;
+            default: () => {
+                right: string;
+                bottom: string;
+            };
+        };
+    }>, {
+        writingBoardRef: import('vue').Ref<any, any>;
+        writingBoardColors: string[];
+        writingBoardColor: import('vue').Ref<string, string>;
+        writingBoardModel: import('vue').Ref<"mark" | "pen" | "eraser", "mark" | "pen" | "eraser">;
+        blackboard: import('vue').Ref<boolean, boolean>;
+        changeModel: (model: "mark" | "pen" | "eraser") => void;
+        clearCanvas: () => void;
+        changeColor: (color: string) => void;
+        closeWritingBoard: () => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "close"[], "close", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        slideWidth: {
+            type: NumberConstructor;
+            required: true;
+        };
+        slideHeight: {
+            type: NumberConstructor;
+            required: true;
+        };
+        position: {
+            type: PropType<import('./WritingBoardTool.vue').Position>;
+            default: () => {
+                right: string;
+                bottom: string;
+            };
+        };
+    }>> & Readonly<{
+        onClose?: ((...args: any[]) => any) | undefined;
+    }>, {
+        position: import('./WritingBoardTool.vue').Position;
+    }, {}, {
+        WritingBoard: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            color: {
+                type: StringConstructor;
+                default: string;
+            };
+            model: {
+                type: PropType<"pen" | "eraser" | "mark">;
+                default: string;
+            };
+            blackboard: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, {
+            mouse: import('vue').Ref<{
+                x: number;
+                y: number;
+            }, {
+                x: number;
+                y: number;
+            } | {
+                x: number;
+                y: number;
+            }>;
+            mouseInCanvas: import('vue').Ref<boolean, boolean>;
+            penSize: import('vue').Ref<number, number>;
+            rubberSize: import('vue').Ref<number, number>;
+            markSize: import('vue').Ref<number, number>;
+            writingBoardRef: import('vue').Ref<HTMLElement | undefined, HTMLElement | undefined>;
+            canvasRef: import('vue').Ref<HTMLCanvasElement | undefined, HTMLCanvasElement | undefined>;
+            canvasWidth: import('vue').Ref<number, number>;
+            canvasHeight: import('vue').Ref<number, number>;
+            handleMousedown: (e: MouseEvent | TouchEvent) => void;
+            handleMousemove: (e: MouseEvent | TouchEvent) => void;
+            handleMouseup: () => void;
+            clearCanvas: () => void;
+            getImageDataURL: () => string | undefined;
+            setImageDataURL: (imageDataURL: string) => void;
+            mousewheelListener: import('lodash').DebouncedFuncLeading<(e: WheelEvent) => void>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            color: {
+                type: StringConstructor;
+                default: string;
+            };
+            model: {
+                type: PropType<"pen" | "eraser" | "mark">;
+                default: string;
+            };
+            blackboard: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{}>, {
+            color: string;
+            model: "mark" | "pen" | "eraser";
+            blackboard: boolean;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=PresenterView.vue.d.ts.map