import { RichTextFeature } from '@bluepic/types';
declare const _sfc_main: import("vue").DefineComponent<{}, {
    value: import("vue").ModelRef<Record<string, any>[keyof T], RichTextFeature[], T[K], T[K]>;
    props: any;
    emit: ((event: unknown, ...args: any[]) => void) | ((event: string, ...args: any[]) => void);
    selection: import("vue").ModelRef<Record<string, any>[keyof T], {
        start: number;
        length: number;
    } | undefined, T[K], T[K]>;
    kebabCase: (str: string) => string;
    renderFeatureInlineStyle: (featureStyle: RichTextFeature['format']) => {};
    richTextValue: import("vue").Ref<{
        text: string;
        format: {
            [k: string]: unknown;
        };
    }[][], RichTextFeature[][] | {
        text: string;
        format: {
            [k: string]: unknown;
        };
    }[][]>;
    visibleParagraphs: import("vue").Ref<{
        text: string;
        format: {
            [k: string]: unknown;
        };
    }[][], {
        text: string;
        format: {
            [k: string]: unknown;
        };
    }[][] | {
        text: string;
        format: {
            [k: string]: unknown;
        };
    }[][]>;
    rawText: import("vue").ComputedRef<string>;
    richtextWarningMessage: import("vue").Ref<string | undefined, string | undefined>;
    richTextInstance: import("vue").Ref<import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
        value: {
            type: ArrayConstructor;
            required: true;
        };
        selection: {
            type: ObjectConstructor;
            required: false;
        };
        userAgentRichText: {
            type: BooleanConstructor;
            required: true;
        };
        renderFeatureInlineStyle: {
            type: FunctionConstructor;
            required: true;
        };
        maxLength: {
            type: NumberConstructor;
            required: true;
        };
        maxLengthPerLine: {
            type: NumberConstructor;
            required: true;
        };
        maxLines: {
            type: NumberConstructor;
            required: true;
        };
        multiline: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
    }>> & Readonly<{
        "onUpdate:focus"?: ((...args: any[]) => any) | undefined;
        "onUpdate:selection"?: ((...args: any[]) => any) | undefined;
        "onUpdate:value"?: ((...args: any[]) => any) | undefined;
        "onUpdate:visible-value"?: ((...args: any[]) => any) | undefined;
        "onUpdate:warning-message"?: ((...args: any[]) => any) | undefined;
    }>, {
        props: any;
        emit: (event: "update:focus" | "update:selection" | "update:value" | "update:visible-value" | "update:warning-message", ...args: any[]) => void;
        preventLinebreaks: import("vue").ComputedRef<boolean>;
        richTextDisplayInstance: import("vue").Ref<import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "blur" | "update")[], import("vue").PublicProps, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }> | undefined, import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "blur" | "update")[], import("vue").PublicProps, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }> | undefined>;
        richTextDisplayGhostInstance: import("vue").Ref<import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "blur" | "update")[], import("vue").PublicProps, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }> | undefined, import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "blur" | "update")[], import("vue").PublicProps, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }> | undefined>;
        richTextEditorDivRef: import("vue").ComputedRef<HTMLDivElement | undefined>;
        handleInputEvent: (event: Event) => void;
        paragraphs: import("vue").Ref<{
            text: string;
            format: {
                [k: string]: unknown;
            };
        }[][], RichTextFeature[][] | {
            text: string;
            format: {
                [k: string]: unknown;
            };
        }[][]>;
        visibleParagraphs: import("vue").Ref<{
            text: string;
            format: {
                [k: string]: unknown;
            };
        }[][], RichTextFeature[][] | {
            text: string;
            format: {
                [k: string]: unknown;
            };
        }[][]>;
        manipulationState: import("vue").Ref<string, string>;
        applyFormat: (selectionStart: number, selectionLength: number, format: {
            [k: string]: unknown;
        }, select?: boolean) => void;
        resolveFeatures: (startIndex: number, length: number) => RichTextFeature[][];
        selection: import("vue").Ref<{
            start: number;
            length: number;
        } | null, {
            start: number;
            length: number;
        } | {
            start: number;
            length: number;
        } | null>;
        handleKeydownEvent: (event: KeyboardEvent) => void;
        warningMessage: import("vue").ComputedRef<"Text is too long" | undefined>;
        focus: import("vue").Ref<boolean, boolean>;
        handleFocus: () => void;
        handleBlur: () => void;
        observer: MutationObserver;
        RichTextDisplay: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "blur" | "update")[], "focus" | "blur" | "update", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:focus" | "update:selection" | "update:value" | "update:visible-value" | "update:warning-message")[], import("vue").PublicProps, {
        multiline: boolean;
    }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<import("vue").ExtractPropTypes<{
        value: {
            type: ArrayConstructor;
            required: true;
        };
        selection: {
            type: ObjectConstructor;
            required: false;
        };
        userAgentRichText: {
            type: BooleanConstructor;
            required: true;
        };
        renderFeatureInlineStyle: {
            type: FunctionConstructor;
            required: true;
        };
        maxLength: {
            type: NumberConstructor;
            required: true;
        };
        maxLengthPerLine: {
            type: NumberConstructor;
            required: true;
        };
        maxLines: {
            type: NumberConstructor;
            required: true;
        };
        multiline: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
    }>> & Readonly<{
        "onUpdate:focus"?: ((...args: any[]) => any) | undefined;
        "onUpdate:selection"?: ((...args: any[]) => any) | undefined;
        "onUpdate:value"?: ((...args: any[]) => any) | undefined;
        "onUpdate:visible-value"?: ((...args: any[]) => any) | undefined;
        "onUpdate:warning-message"?: ((...args: any[]) => any) | undefined;
    }>, {
        props: any;
        emit: (event: "update:focus" | "update:selection" | "update:value" | "update:visible-value" | "update:warning-message", ...args: any[]) => void;
        preventLinebreaks: import("vue").ComputedRef<boolean>;
        richTextDisplayInstance: import("vue").Ref<import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "blur" | "update")[], import("vue").PublicProps, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }> | undefined, import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "blur" | "update")[], import("vue").PublicProps, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }> | undefined>;
        richTextDisplayGhostInstance: import("vue").Ref<import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "blur" | "update")[], import("vue").PublicProps, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }> | undefined, import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "blur" | "update")[], import("vue").PublicProps, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }> | undefined>;
        richTextEditorDivRef: import("vue").ComputedRef<HTMLDivElement | undefined>;
        handleInputEvent: (event: Event) => void;
        paragraphs: import("vue").Ref<{
            text: string;
            format: {
                [k: string]: unknown;
            };
        }[][], RichTextFeature[][] | {
            text: string;
            format: {
                [k: string]: unknown;
            };
        }[][]>;
        visibleParagraphs: import("vue").Ref<{
            text: string;
            format: {
                [k: string]: unknown;
            };
        }[][], RichTextFeature[][] | {
            text: string;
            format: {
                [k: string]: unknown;
            };
        }[][]>;
        manipulationState: import("vue").Ref<string, string>;
        applyFormat: (selectionStart: number, selectionLength: number, format: {
            [k: string]: unknown;
        }, select?: boolean) => void;
        resolveFeatures: (startIndex: number, length: number) => RichTextFeature[][];
        selection: import("vue").Ref<{
            start: number;
            length: number;
        } | null, {
            start: number;
            length: number;
        } | {
            start: number;
            length: number;
        } | null>;
        handleKeydownEvent: (event: KeyboardEvent) => void;
        warningMessage: import("vue").ComputedRef<"Text is too long" | undefined>;
        focus: import("vue").Ref<boolean, boolean>;
        handleFocus: () => void;
        handleBlur: () => void;
        observer: MutationObserver;
        RichTextDisplay: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "blur" | "update")[], "focus" | "blur" | "update", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    }, {}, {}, {}, {
        multiline: boolean;
    }> | undefined, import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
        value: {
            type: ArrayConstructor;
            required: true;
        };
        selection: {
            type: ObjectConstructor;
            required: false;
        };
        userAgentRichText: {
            type: BooleanConstructor;
            required: true;
        };
        renderFeatureInlineStyle: {
            type: FunctionConstructor;
            required: true;
        };
        maxLength: {
            type: NumberConstructor;
            required: true;
        };
        maxLengthPerLine: {
            type: NumberConstructor;
            required: true;
        };
        maxLines: {
            type: NumberConstructor;
            required: true;
        };
        multiline: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
    }>> & Readonly<{
        "onUpdate:focus"?: ((...args: any[]) => any) | undefined;
        "onUpdate:selection"?: ((...args: any[]) => any) | undefined;
        "onUpdate:value"?: ((...args: any[]) => any) | undefined;
        "onUpdate:visible-value"?: ((...args: any[]) => any) | undefined;
        "onUpdate:warning-message"?: ((...args: any[]) => any) | undefined;
    }>, {
        props: any;
        emit: (event: "update:focus" | "update:selection" | "update:value" | "update:visible-value" | "update:warning-message", ...args: any[]) => void;
        preventLinebreaks: import("vue").ComputedRef<boolean>;
        richTextDisplayInstance: import("vue").Ref<import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "blur" | "update")[], import("vue").PublicProps, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }> | undefined, import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "blur" | "update")[], import("vue").PublicProps, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }> | undefined>;
        richTextDisplayGhostInstance: import("vue").Ref<import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "blur" | "update")[], import("vue").PublicProps, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }> | undefined, import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "blur" | "update")[], import("vue").PublicProps, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }> | undefined>;
        richTextEditorDivRef: import("vue").ComputedRef<HTMLDivElement | undefined>;
        handleInputEvent: (event: Event) => void;
        paragraphs: import("vue").Ref<{
            text: string;
            format: {
                [k: string]: unknown;
            };
        }[][], RichTextFeature[][] | {
            text: string;
            format: {
                [k: string]: unknown;
            };
        }[][]>;
        visibleParagraphs: import("vue").Ref<{
            text: string;
            format: {
                [k: string]: unknown;
            };
        }[][], RichTextFeature[][] | {
            text: string;
            format: {
                [k: string]: unknown;
            };
        }[][]>;
        manipulationState: import("vue").Ref<string, string>;
        applyFormat: (selectionStart: number, selectionLength: number, format: {
            [k: string]: unknown;
        }, select?: boolean) => void;
        resolveFeatures: (startIndex: number, length: number) => RichTextFeature[][];
        selection: import("vue").Ref<{
            start: number;
            length: number;
        } | null, {
            start: number;
            length: number;
        } | {
            start: number;
            length: number;
        } | null>;
        handleKeydownEvent: (event: KeyboardEvent) => void;
        warningMessage: import("vue").ComputedRef<"Text is too long" | undefined>;
        focus: import("vue").Ref<boolean, boolean>;
        handleFocus: () => void;
        handleBlur: () => void;
        observer: MutationObserver;
        RichTextDisplay: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "blur" | "update")[], "focus" | "blur" | "update", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:focus" | "update:selection" | "update:value" | "update:visible-value" | "update:warning-message")[], import("vue").PublicProps, {
        multiline: boolean;
    }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<import("vue").ExtractPropTypes<{
        value: {
            type: ArrayConstructor;
            required: true;
        };
        selection: {
            type: ObjectConstructor;
            required: false;
        };
        userAgentRichText: {
            type: BooleanConstructor;
            required: true;
        };
        renderFeatureInlineStyle: {
            type: FunctionConstructor;
            required: true;
        };
        maxLength: {
            type: NumberConstructor;
            required: true;
        };
        maxLengthPerLine: {
            type: NumberConstructor;
            required: true;
        };
        maxLines: {
            type: NumberConstructor;
            required: true;
        };
        multiline: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
    }>> & Readonly<{
        "onUpdate:focus"?: ((...args: any[]) => any) | undefined;
        "onUpdate:selection"?: ((...args: any[]) => any) | undefined;
        "onUpdate:value"?: ((...args: any[]) => any) | undefined;
        "onUpdate:visible-value"?: ((...args: any[]) => any) | undefined;
        "onUpdate:warning-message"?: ((...args: any[]) => any) | undefined;
    }>, {
        props: any;
        emit: (event: "update:focus" | "update:selection" | "update:value" | "update:visible-value" | "update:warning-message", ...args: any[]) => void;
        preventLinebreaks: import("vue").ComputedRef<boolean>;
        richTextDisplayInstance: import("vue").Ref<import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "blur" | "update")[], import("vue").PublicProps, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }> | undefined, import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "blur" | "update")[], import("vue").PublicProps, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }> | undefined>;
        richTextDisplayGhostInstance: import("vue").Ref<import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "blur" | "update")[], import("vue").PublicProps, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }> | undefined, import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "blur" | "update")[], import("vue").PublicProps, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }> | undefined>;
        richTextEditorDivRef: import("vue").ComputedRef<HTMLDivElement | undefined>;
        handleInputEvent: (event: Event) => void;
        paragraphs: import("vue").Ref<{
            text: string;
            format: {
                [k: string]: unknown;
            };
        }[][], RichTextFeature[][] | {
            text: string;
            format: {
                [k: string]: unknown;
            };
        }[][]>;
        visibleParagraphs: import("vue").Ref<{
            text: string;
            format: {
                [k: string]: unknown;
            };
        }[][], RichTextFeature[][] | {
            text: string;
            format: {
                [k: string]: unknown;
            };
        }[][]>;
        manipulationState: import("vue").Ref<string, string>;
        applyFormat: (selectionStart: number, selectionLength: number, format: {
            [k: string]: unknown;
        }, select?: boolean) => void;
        resolveFeatures: (startIndex: number, length: number) => RichTextFeature[][];
        selection: import("vue").Ref<{
            start: number;
            length: number;
        } | null, {
            start: number;
            length: number;
        } | {
            start: number;
            length: number;
        } | null>;
        handleKeydownEvent: (event: KeyboardEvent) => void;
        warningMessage: import("vue").ComputedRef<"Text is too long" | undefined>;
        focus: import("vue").Ref<boolean, boolean>;
        handleFocus: () => void;
        handleBlur: () => void;
        observer: MutationObserver;
        RichTextDisplay: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "blur" | "update")[], "focus" | "blur" | "update", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    }, {}, {}, {}, {
        multiline: boolean;
    }> | undefined>;
    focus: import("vue").Ref<boolean, boolean>;
    RichText: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        value: {
            type: ArrayConstructor;
            required: true;
        };
        selection: {
            type: ObjectConstructor;
            required: false;
        };
        userAgentRichText: {
            type: BooleanConstructor;
            required: true;
        };
        renderFeatureInlineStyle: {
            type: FunctionConstructor;
            required: true;
        };
        maxLength: {
            type: NumberConstructor;
            required: true;
        };
        maxLengthPerLine: {
            type: NumberConstructor;
            required: true;
        };
        maxLines: {
            type: NumberConstructor;
            required: true;
        };
        multiline: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
    }>, {
        props: any;
        emit: (event: "update:focus" | "update:selection" | "update:value" | "update:visible-value" | "update:warning-message", ...args: any[]) => void;
        preventLinebreaks: import("vue").ComputedRef<boolean>;
        richTextDisplayInstance: import("vue").Ref<import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "blur" | "update")[], import("vue").PublicProps, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }> | undefined, import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "blur" | "update")[], import("vue").PublicProps, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }> | undefined>;
        richTextDisplayGhostInstance: import("vue").Ref<import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "blur" | "update")[], import("vue").PublicProps, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }> | undefined, import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "blur" | "update")[], import("vue").PublicProps, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }> | undefined>;
        richTextEditorDivRef: import("vue").ComputedRef<HTMLDivElement | undefined>;
        handleInputEvent: (event: Event) => void;
        paragraphs: import("vue").Ref<{
            text: string;
            format: {
                [k: string]: unknown;
            };
        }[][], RichTextFeature[][] | {
            text: string;
            format: {
                [k: string]: unknown;
            };
        }[][]>;
        visibleParagraphs: import("vue").Ref<{
            text: string;
            format: {
                [k: string]: unknown;
            };
        }[][], RichTextFeature[][] | {
            text: string;
            format: {
                [k: string]: unknown;
            };
        }[][]>;
        manipulationState: import("vue").Ref<string, string>;
        applyFormat: (selectionStart: number, selectionLength: number, format: {
            [k: string]: unknown;
        }, select?: boolean) => void;
        resolveFeatures: (startIndex: number, length: number) => RichTextFeature[][];
        selection: import("vue").Ref<{
            start: number;
            length: number;
        } | null, {
            start: number;
            length: number;
        } | {
            start: number;
            length: number;
        } | null>;
        handleKeydownEvent: (event: KeyboardEvent) => void;
        warningMessage: import("vue").ComputedRef<"Text is too long" | undefined>;
        focus: import("vue").Ref<boolean, boolean>;
        handleFocus: () => void;
        handleBlur: () => void;
        observer: MutationObserver;
        RichTextDisplay: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>, {
            props: any;
            emit: (event: "focus" | "blur" | "update", ...args: any[]) => void;
            richTextEditorDivRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
            lazyParagraphs: import("vue").Ref<any, any>;
            handleInputEvent: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            richTextGlobalScopedStyleId: string;
            richTextGlobalScopedStyleDataAttr: string;
            writeCSS: (cssRules: import("vue").StyleValue) => string;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "blur" | "update")[], "focus" | "blur" | "update", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            paragraphs: {
                type: ArrayConstructor;
                required: true;
            };
            noLazy: {
                type: BooleanConstructor;
                required: false;
            };
            ghost: {
                type: BooleanConstructor;
                required: false;
            };
            debug: {
                type: BooleanConstructor;
                required: false;
            };
        }>> & Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onUpdate?: ((...args: any[]) => any) | undefined;
        }>, {
            debug: boolean;
            noLazy: boolean;
            ghost: boolean;
        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:focus" | "update:selection" | "update:value" | "update:visible-value" | "update:warning-message")[], "update:focus" | "update:selection" | "update:value" | "update:visible-value" | "update:warning-message", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
        value: {
            type: ArrayConstructor;
            required: true;
        };
        selection: {
            type: ObjectConstructor;
            required: false;
        };
        userAgentRichText: {
            type: BooleanConstructor;
            required: true;
        };
        renderFeatureInlineStyle: {
            type: FunctionConstructor;
            required: true;
        };
        maxLength: {
            type: NumberConstructor;
            required: true;
        };
        maxLengthPerLine: {
            type: NumberConstructor;
            required: true;
        };
        maxLines: {
            type: NumberConstructor;
            required: true;
        };
        multiline: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
    }>> & Readonly<{
        "onUpdate:focus"?: ((...args: any[]) => any) | undefined;
        "onUpdate:selection"?: ((...args: any[]) => any) | undefined;
        "onUpdate:value"?: ((...args: any[]) => any) | undefined;
        "onUpdate:visible-value"?: ((...args: any[]) => any) | undefined;
        "onUpdate:warning-message"?: ((...args: any[]) => any) | undefined;
    }>, {
        multiline: boolean;
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {} | {
    [x: string]: any;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
export default _sfc_main;
//# sourceMappingURL=BxRichtextInput.vue.d.ts.map