import type { Paragraph } from './types';
import { TickerStatus } from '@vunk/shared/enum';
import { ParagraphStatus } from './const';
declare const _default: typeof __VLS_export;
export default _default;
declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
    render: {
        type: import("vue").PropType<(text: string) => string>;
        default: typeof import("./const").defaultRender;
    };
    data: {
        type: {
            (arrayLength: number): Paragraph[];
            (...items: Paragraph[]): Paragraph[];
            new (arrayLength: number): Paragraph[];
            new (...items: Paragraph[]): Paragraph[];
            isArray(arg: any): arg is any[];
            readonly prototype: any[];
            from<T>(arrayLike: ArrayLike<T>): T[];
            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
            of<T>(...items: T[]): T[];
            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
            readonly [Symbol.species]: ArrayConstructor;
        };
        default: undefined;
    };
    source: {
        type: StringConstructor;
        default: string;
    };
    delay: {
        type: NumberConstructor;
        default: number;
    };
    separators: {
        type: {
            (arrayLength: number): string[];
            (...items: string[]): string[];
            new (arrayLength: number): string[];
            new (...items: string[]): string[];
            isArray(arg: any): arg is any[];
            readonly prototype: any[];
            from<T>(arrayLike: ArrayLike<T>): T[];
            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
            of<T>(...items: T[]): T[];
            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
            readonly [Symbol.species]: ArrayConstructor;
        };
        default: () => string[];
    };
    keepRead: {
        type: BooleanConstructor;
        default: boolean;
    };
    textToSpeech: {
        type: import("vue").PropType<import("./types").TextToSpeech>;
        default: undefined;
    };
    processing: {
        type: import("vue").PropType<(paragraph: Paragraph) => void>;
        default: import("@vunk/shared").AnyFunc;
    };
    status: {
        type: import("vue").PropType<TickerStatus>;
        default: TickerStatus;
    };
    paragraphMinlength: {
        type: NumberConstructor;
        default: number;
    };
    disabled: {
        type: BooleanConstructor;
        default: boolean;
    };
}>, {
    theData: import("vue").ComputedRef<Paragraph[]>;
    ParagraphStatus: typeof ParagraphStatus;
    fulfilledTextValue: import("vue").ComputedRef<string>;
    processingParagraph: (paragraph: Paragraph) => Promise<void>;
    setData: (obj: any, e: import("@vunk/core").SetDataEvent) => void;
    Broadcast: typeof TickerStatus;
    isParagraphEnabled: (currentIndex: number) => boolean;
    TickerStatus: typeof TickerStatus;
    handleParagraphStatus: (para: Paragraph, v: TickerStatus) => void;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
    setData: (e: import("@vunk/core").SetDataEvent) => import("@vunk/core").SetDataEvent;
    'update:status': (_: TickerStatus) => boolean;
    paragraphLoad: (_: import("./types").ParagraphLoadEvent) => boolean;
    complete: () => boolean;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
    render: {
        type: import("vue").PropType<(text: string) => string>;
        default: typeof import("./const").defaultRender;
    };
    data: {
        type: {
            (arrayLength: number): Paragraph[];
            (...items: Paragraph[]): Paragraph[];
            new (arrayLength: number): Paragraph[];
            new (...items: Paragraph[]): Paragraph[];
            isArray(arg: any): arg is any[];
            readonly prototype: any[];
            from<T>(arrayLike: ArrayLike<T>): T[];
            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
            of<T>(...items: T[]): T[];
            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
            readonly [Symbol.species]: ArrayConstructor;
        };
        default: undefined;
    };
    source: {
        type: StringConstructor;
        default: string;
    };
    delay: {
        type: NumberConstructor;
        default: number;
    };
    separators: {
        type: {
            (arrayLength: number): string[];
            (...items: string[]): string[];
            new (arrayLength: number): string[];
            new (...items: string[]): string[];
            isArray(arg: any): arg is any[];
            readonly prototype: any[];
            from<T>(arrayLike: ArrayLike<T>): T[];
            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
            of<T>(...items: T[]): T[];
            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
            readonly [Symbol.species]: ArrayConstructor;
        };
        default: () => string[];
    };
    keepRead: {
        type: BooleanConstructor;
        default: boolean;
    };
    textToSpeech: {
        type: import("vue").PropType<import("./types").TextToSpeech>;
        default: undefined;
    };
    processing: {
        type: import("vue").PropType<(paragraph: Paragraph) => void>;
        default: import("@vunk/shared").AnyFunc;
    };
    status: {
        type: import("vue").PropType<TickerStatus>;
        default: TickerStatus;
    };
    paragraphMinlength: {
        type: NumberConstructor;
        default: number;
    };
    disabled: {
        type: BooleanConstructor;
        default: boolean;
    };
}>> & Readonly<{
    onComplete?: (() => any) | undefined;
    "onUpdate:status"?: ((_: TickerStatus) => any) | undefined;
    onSetData?: ((e: import("@vunk/core").SetDataEvent) => any) | undefined;
    onParagraphLoad?: ((_: import("./types").ParagraphLoadEvent) => any) | undefined;
}>, {
    data: Paragraph[];
    source: string;
    disabled: boolean;
    render: (text: string) => string;
    processing: (paragraph: Paragraph) => void;
    delay: number;
    status: TickerStatus;
    paragraphMinlength: number;
    separators: string[];
    keepRead: boolean;
    textToSpeech: import("./types").TextToSpeech;
}, {}, {
    ParagraphView: {
        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
            enable: {
                type: BooleanConstructor;
                default: boolean;
            };
            status: {
                type: import("vue").PropType<ParagraphStatus>;
                default: ParagraphStatus;
            };
            processing: {
                type: import("vue").PropType<import("@vunk/shared").AnyFunc>;
                default: import("@vunk/shared").AnyFunc;
            };
        }>> & Readonly<{
            "onUpdate:status"?: ((...args: any[]) => any) | undefined;
        }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
            "update:status": (...args: any[]) => void;
        }, import("vue").PublicProps, {
            processing: import("@vunk/shared").AnyFunc;
            status: ParagraphStatus;
            enable: boolean;
        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("vue").ExtractPropTypes<{
            enable: {
                type: BooleanConstructor;
                default: boolean;
            };
            status: {
                type: import("vue").PropType<ParagraphStatus>;
                default: ParagraphStatus;
            };
            processing: {
                type: import("vue").PropType<import("@vunk/shared").AnyFunc>;
                default: import("@vunk/shared").AnyFunc;
            };
        }>> & Readonly<{
            "onUpdate:status"?: ((...args: any[]) => any) | undefined;
        }>, {}, {}, {}, {}, {
            processing: import("@vunk/shared").AnyFunc;
            status: ParagraphStatus;
            enable: boolean;
        }>;
        __isFragment?: never;
        __isTeleport?: never;
        __isSuspense?: never;
    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
        enable: {
            type: BooleanConstructor;
            default: boolean;
        };
        status: {
            type: import("vue").PropType<ParagraphStatus>;
            default: ParagraphStatus;
        };
        processing: {
            type: import("vue").PropType<import("@vunk/shared").AnyFunc>;
            default: import("@vunk/shared").AnyFunc;
        };
    }>> & Readonly<{
        "onUpdate:status"?: ((...args: any[]) => any) | undefined;
    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
        "update:status": (...args: any[]) => void;
    }, string, {
        processing: import("@vunk/shared").AnyFunc;
        status: ParagraphStatus;
        enable: boolean;
    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
        $slots: {
            default?: (props: {
                deferred: import("@vunk/shared/promise").Deferred<any>;
            }) => any;
        };
    });
    HowlerSpeechView: {
        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
            source: {
                type: StringConstructor;
                default: string;
            };
            status: {
                type: import("vue").PropType<TickerStatus>;
                default: TickerStatus;
            };
        }>> & Readonly<{
            onError?: ((...args: any[]) => any) | undefined;
            onLoad?: ((...args: any[]) => any) | undefined;
            "onUpdate:status"?: ((...args: any[]) => any) | undefined;
        }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
            error: (...args: any[]) => void;
            load: (...args: any[]) => void;
            "update:status": (...args: any[]) => void;
        }, import("vue").PublicProps, {
            source: string;
            status: TickerStatus;
        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("vue").ExtractPropTypes<{
            source: {
                type: StringConstructor;
                default: string;
            };
            status: {
                type: import("vue").PropType<TickerStatus>;
                default: TickerStatus;
            };
        }>> & Readonly<{
            onError?: ((...args: any[]) => any) | undefined;
            onLoad?: ((...args: any[]) => any) | undefined;
            "onUpdate:status"?: ((...args: any[]) => any) | undefined;
        }>, {}, {}, {}, {}, {
            source: string;
            status: TickerStatus;
        }>;
        __isFragment?: never;
        __isTeleport?: never;
        __isSuspense?: never;
    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
        source: {
            type: StringConstructor;
            default: string;
        };
        status: {
            type: import("vue").PropType<TickerStatus>;
            default: TickerStatus;
        };
    }>> & Readonly<{
        onError?: ((...args: any[]) => any) | undefined;
        onLoad?: ((...args: any[]) => any) | undefined;
        "onUpdate:status"?: ((...args: any[]) => any) | undefined;
    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
        error: (...args: any[]) => void;
        load: (...args: any[]) => void;
        "update:status": (...args: any[]) => void;
    }, string, {
        source: string;
        status: TickerStatus;
    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
        $slots: {
            default?: (props: {
                status: TickerStatus;
            }) => any;
        };
    });
    VkTypingMarkdown: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        source: {
            type: StringConstructor;
            default: string;
        };
        delay: {
            type: NumberConstructor;
            default: number;
        };
        pause: {
            type: BooleanConstructor;
            default: boolean;
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        markdownItSetup: {
            type: import("vue").PropType<(md: import("markdown-it-async").MarkdownItAsync) => void>;
            default: null;
        };
        finished: {
            type: BooleanConstructor;
        };
        loading: {
            type: BooleanConstructor;
            default: boolean;
        };
    }>, {
        htmlText: import("vue").Ref<string, string>;
        isDebouncedTyping: Readonly<import("vue").Ref<boolean, boolean>>;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
        typing: null;
        'update:finished': null;
    }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
        source: {
            type: StringConstructor;
            default: string;
        };
        delay: {
            type: NumberConstructor;
            default: number;
        };
        pause: {
            type: BooleanConstructor;
            default: boolean;
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        markdownItSetup: {
            type: import("vue").PropType<(md: import("markdown-it-async").MarkdownItAsync) => void>;
            default: null;
        };
        finished: {
            type: BooleanConstructor;
        };
        loading: {
            type: BooleanConstructor;
            default: boolean;
        };
    }>> & Readonly<{
        onTyping?: ((...args: any[]) => any) | undefined;
        "onUpdate:finished"?: ((...args: any[]) => any) | undefined;
    }>, {
        source: string;
        pause: boolean;
        disabled: boolean;
        loading: boolean;
        delay: number;
        markdownItSetup: (md: import("markdown-it-async").MarkdownItAsync) => void;
        finished: boolean;
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;