@vervedoc/ppt 1.0.2

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

@@ -0,0 +1,1352 @@
+import { PropType } from 'vue';
+declare const _default: 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>;
+export default _default;
+//# sourceMappingURL=ScreenSlideList.vue.d.ts.map