@bluepic/embed 0.1.0

package/lib/components/BxRichtextInput.vue.d.ts

@@ -0,0 +1,2413 @@
+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']) => {
+        [k: string]: any;
+    };
+    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