@quoreadmin/ui 1.4.0 → 1.4.2

package/dist/src/components/wysiwyg/wysiwyg.d.ts

@@ -0,0 +1,1560 @@
+import { PropType } from 'vue';
+declare const QWysiwyg: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    attachments: {
+        type: PropType<File[]>;
+        default: () => never[];
+    };
+    allowEmojis: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    allowAttachments: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    allowFormatting: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Specify file types allowed */
+    filesAllowed: {
+        type: StringConstructor;
+        default: string;
+    };
+    expands: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isStacked: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isStandalone: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    processing: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {
+    colors: import('tailwindcss/types/config').ResolvableTo<import('tailwindcss/types/config').RecursiveKeyValuePair<string, string>> | undefined;
+    colorExclusions: string[];
+    editor: import('vue').ShallowRef<import('@tiptap/vue-3').Editor | undefined, import('@tiptap/vue-3').Editor | undefined>;
+    editorRef: import('vue').Ref<any, any>;
+    emojiPickerElement: import('vue').Ref<any, any>;
+    showEmojiPicker: import('vue').Ref<boolean, boolean>;
+    emojiSearch: import('vue').Ref<string, string>;
+    invoker: import('vue').Ref<any, any>;
+    isExpanded: import('vue').ComputedRef<boolean>;
+    multiUploader: import('vue').Ref<any, any>;
+    showColorMenu: import('vue').Ref<boolean, boolean>;
+    focused: import('vue').Ref<boolean, boolean>;
+    files: import('vue').ComputedRef<File[]>;
+    showFormatOptions: import('vue').Ref<boolean, boolean>;
+    uploadedfiles: import('vue').Ref<{
+        readonly lastModified: number;
+        readonly name: string;
+        readonly webkitRelativePath: string;
+        readonly size: number;
+        readonly type: string;
+        arrayBuffer: () => Promise<ArrayBuffer>;
+        bytes: () => Promise<Uint8Array<ArrayBuffer>>;
+        slice: (start?: number, end?: number, contentType?: string) => Blob;
+        stream: () => ReadableStream<Uint8Array<ArrayBuffer>>;
+        text: () => Promise<string>;
+    }[], File[] | {
+        readonly lastModified: number;
+        readonly name: string;
+        readonly webkitRelativePath: string;
+        readonly size: number;
+        readonly type: string;
+        arrayBuffer: () => Promise<ArrayBuffer>;
+        bytes: () => Promise<Uint8Array<ArrayBuffer>>;
+        slice: (start?: number, end?: number, contentType?: string) => Blob;
+        stream: () => ReadableStream<Uint8Array<ArrayBuffer>>;
+        text: () => Promise<string>;
+    }[]>;
+    fileUploadRef: import('vue').Ref<any, any>;
+    wysiwygRef: import('vue').Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    setColor: import('vue').ComputedRef<string>;
+    mdAndLarger: import('vue').ComputedRef<boolean>;
+    setLink: () => void;
+    selectColor: (hex: string) => void;
+    showColors: () => void;
+    onClickAction: () => void;
+    onClickOutColors: () => void;
+    attachFiles: () => void;
+    appendEmoji: (emoji: string) => void;
+    onSelectEmoji: (emoji: any) => void;
+    onSelectFiles: (event: any) => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("update:model-value" | "update:attachments" | "keyboard-open")[], "update:model-value" | "update:attachments" | "keyboard-open", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    attachments: {
+        type: PropType<File[]>;
+        default: () => never[];
+    };
+    allowEmojis: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    allowAttachments: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    allowFormatting: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Specify file types allowed */
+    filesAllowed: {
+        type: StringConstructor;
+        default: string;
+    };
+    expands: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isStacked: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isStandalone: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    processing: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    "onUpdate:model-value"?: ((...args: any[]) => any) | undefined;
+    "onUpdate:attachments"?: ((...args: any[]) => any) | undefined;
+    "onKeyboard-open"?: ((...args: any[]) => any) | undefined;
+}>, {
+    modelValue: string;
+    placeholder: string;
+    disabled: boolean;
+    processing: boolean;
+    filesAllowed: string;
+    expands: boolean;
+    attachments: File[];
+    allowEmojis: boolean;
+    allowAttachments: boolean;
+    allowFormatting: boolean;
+    isStacked: boolean;
+    isStandalone: boolean;
+}, {}, {
+    EditorContent: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        editor: {
+            default: null;
+            type: PropType<import('@tiptap/vue-3').Editor>;
+        };
+    }>, {
+        rootEl: import('vue').Ref<Element | undefined, Element | undefined>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        editor: {
+            default: null;
+            type: PropType<import('@tiptap/vue-3').Editor>;
+        };
+    }>> & Readonly<{}>, {
+        editor: import('@tiptap/vue-3').Editor;
+    }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    EmojiPicker: import('vue').DefineComponent<{
+        native: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        hideSearch: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        hideGroupIcons: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        hideGroupNames: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        staticTexts: {
+            type: ObjectConstructor;
+            default: () => {};
+        };
+        disableStickyGroupNames: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        disabledGroups: {
+            type: ArrayConstructor;
+            default: () => never[];
+        };
+        groupNames: {
+            type: ObjectConstructor;
+            default: () => {};
+        };
+        disableSkinTones: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        text: {
+            type: StringConstructor;
+            default: string;
+        };
+        mode: {
+            type: StringConstructor;
+            default: string;
+        };
+        offset: {
+            type: NumberConstructor;
+            default: number;
+        };
+        additionalGroups: {
+            type: ObjectConstructor;
+            default: () => {};
+        };
+        groupOrder: {
+            type: ArrayConstructor;
+            default: () => never[];
+        };
+        groupIcons: {
+            type: ObjectConstructor;
+            default: () => {};
+        };
+        pickerType: {
+            type: StringConstructor;
+            default: string;
+        };
+        displayRecent: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        theme: {
+            type: PropType<"auto" | "dark" | "light">;
+            default: string;
+        };
+    }, {
+        type: string;
+        input: import('vue').Ref<string>;
+        onChangeText: (text: string | undefined) => void;
+    }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        'update:text': (text: string) => true;
+        select: (emoji: import('vue3-emoji-picker').EmojiExt) => true;
+    }, string, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, Readonly<import('vue').ExtractPropTypes<{
+        native: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        hideSearch: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        hideGroupIcons: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        hideGroupNames: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        staticTexts: {
+            type: ObjectConstructor;
+            default: () => {};
+        };
+        disableStickyGroupNames: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        disabledGroups: {
+            type: ArrayConstructor;
+            default: () => never[];
+        };
+        groupNames: {
+            type: ObjectConstructor;
+            default: () => {};
+        };
+        disableSkinTones: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        text: {
+            type: StringConstructor;
+            default: string;
+        };
+        mode: {
+            type: StringConstructor;
+            default: string;
+        };
+        offset: {
+            type: NumberConstructor;
+            default: number;
+        };
+        additionalGroups: {
+            type: ObjectConstructor;
+            default: () => {};
+        };
+        groupOrder: {
+            type: ArrayConstructor;
+            default: () => never[];
+        };
+        groupIcons: {
+            type: ObjectConstructor;
+            default: () => {};
+        };
+        pickerType: {
+            type: StringConstructor;
+            default: string;
+        };
+        displayRecent: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        theme: {
+            type: PropType<"auto" | "dark" | "light">;
+            default: string;
+        };
+    }>> & {
+        onSelect?: ((emoji: import('vue3-emoji-picker').EmojiExt) => any) | undefined;
+        "onUpdate:text"?: ((text: string) => any) | undefined;
+    }, {
+        native: boolean;
+        hideSearch: boolean;
+        hideGroupIcons: boolean;
+        hideGroupNames: boolean;
+        staticTexts: Record<string, any>;
+        disabledGroups: unknown[];
+        groupNames: Record<string, any>;
+        displayRecent: boolean;
+        additionalGroups: Record<string, any>;
+        groupOrder: unknown[];
+        groupIcons: Record<string, any>;
+        mode: string;
+        disableStickyGroupNames: boolean;
+        text: string;
+        disableSkinTones: boolean;
+        offset: number;
+        pickerType: string;
+        theme: "auto" | "dark" | "light";
+    }>;
+    QFileUpload: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        name: any;
+        files: {
+            type: ArrayConstructor;
+            default: () => never[];
+        };
+        url: {
+            type: StringConstructor;
+            default: string;
+        };
+        multiple: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        filesAllowed: {
+            type: StringConstructor;
+            default: string;
+        };
+        maxFileSize: {
+            type: PropType<any>;
+            default: number;
+        };
+        autoUpload: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        customUpload: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        expands: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        processing: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>, {
+        fileUpload: import('vue').Ref<any, any>;
+        dropZoneRef: import('vue').Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+        allFiles: import('vue').ComputedRef<unknown[]>;
+        sizeErrors: import('vue').Ref<string[], string[]>;
+        typeErrors: import('vue').Ref<string[], string[]>;
+        isOverDropZone: import('vue').ShallowRef<boolean>;
+        displayAllowedTypes: import('vue').ComputedRef<string>;
+        clear: () => void;
+        clearErrors: () => void;
+        getFileExtension: (file: any) => string;
+        getTypeClass: (fileType: any) => any;
+        isValidFileType: (file: any) => boolean;
+        isWildcard: (fileType: any) => boolean;
+        onBeforeSelect: (e: any) => void;
+        onUpload: () => void;
+        onUploadError: (event: any) => void;
+        onUploading: (event: any) => void;
+        onRemoveFile: (fileToRemove: File) => void;
+        onSelectedFiles: (event: any) => void;
+        mq: {
+            xs: boolean;
+            sm: boolean;
+            md: boolean;
+            lg: boolean;
+            xl: boolean;
+            'sm-md': boolean;
+            'md-lg': boolean;
+            'lg-xl': boolean;
+            'sm-down': boolean;
+        };
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("file-list" | "upload-error" | "uploading")[], "file-list" | "upload-error" | "uploading", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        name: any;
+        files: {
+            type: ArrayConstructor;
+            default: () => never[];
+        };
+        url: {
+            type: StringConstructor;
+            default: string;
+        };
+        multiple: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        filesAllowed: {
+            type: StringConstructor;
+            default: string;
+        };
+        maxFileSize: {
+            type: PropType<any>;
+            default: number;
+        };
+        autoUpload: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        customUpload: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        expands: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        processing: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{
+        "onFile-list"?: ((...args: any[]) => any) | undefined;
+        "onUpload-error"?: ((...args: any[]) => any) | undefined;
+        onUploading?: ((...args: any[]) => any) | undefined;
+    }>, {
+        name: any;
+        multiple: boolean;
+        disabled: boolean;
+        url: string;
+        processing: boolean;
+        files: unknown[];
+        filesAllowed: string;
+        maxFileSize: any;
+        autoUpload: boolean;
+        customUpload: boolean;
+        expands: boolean;
+    }, {}, {
+        FileUpload: typeof import('primevue/fileupload').default;
+        QBadge: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            color: {
+                type: StringConstructor;
+                default: string;
+            };
+            shape: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {
+            bgColor: import('vue').ComputedRef<string>;
+            hasIcon: import('vue').ComputedRef<boolean>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            color: {
+                type: StringConstructor;
+                default: string;
+            };
+            shape: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{}>, {
+            color: string;
+            shape: string;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        QImageGallery: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            id: {
+                type: StringConstructor;
+                default: string;
+            };
+            files: any;
+            thumbnailsVisible: {
+                type: NumberConstructor;
+                default: number;
+            };
+            showOnHover: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            showThumbnails: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            showRemove: {
+                type: PropType<boolean | number>;
+                default: boolean;
+            };
+            baseZIndex: {
+                type: NumberConstructor;
+                default: number;
+            };
+            wrap: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            processing: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, {
+            menuActions: {
+                text: string;
+            }[];
+            linkActions: import('vue').ComputedRef<{
+                text: string;
+                classes: string;
+                event: (file?: import('../image-gallery/image-gallery').NormalizedFileType | null) => void;
+            }[]>;
+            deviceType: import('vue').Ref<string, string>;
+            container: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+            containerWidth: import('vue').ComputedRef<number | undefined>;
+            featuredPhoto: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+            longPressRef: import('vue').Ref<HTMLElement[], HTMLElement[]>;
+            longPressedHook: import('vue').Ref<boolean, boolean>;
+            isSwiping: import('vue').ShallowRef<boolean>;
+            lengthX: import('vue').ComputedRef<number>;
+            left: import('vue').Ref<string, string>;
+            opacity: import('vue').Ref<number, number>;
+            scale: import('vue').Ref<number, number>;
+            showCarousel: import('vue').Ref<boolean, boolean>;
+            showFileViewer: import('vue').Ref<boolean, boolean>;
+            active: import('vue').Ref<number, number>;
+            activeAttachment: import('vue').Ref<{
+                id: string | number;
+                extension: string;
+                icon?: string | undefined;
+                isImage: boolean;
+                name: string;
+                originalFile: {
+                    id: string | number;
+                    mimetype: string;
+                    type: string;
+                    original: {
+                        name: string;
+                        url: string;
+                    };
+                    thumbnail: {
+                        name: string;
+                        url: string;
+                    } | null;
+                    isHovered?: boolean | undefined;
+                } | {
+                    readonly lastModified: number;
+                    readonly name: string;
+                    readonly webkitRelativePath: string;
+                    readonly size: number;
+                    readonly type: string;
+                    arrayBuffer: () => Promise<ArrayBuffer>;
+                    bytes: () => Promise<Uint8Array<ArrayBuffer>>;
+                    slice: (start?: number, end?: number, contentType?: string) => Blob;
+                    stream: () => ReadableStream<Uint8Array<ArrayBuffer>>;
+                    text: () => Promise<string>;
+                };
+                type: string;
+                url: string;
+            } | null, import('../image-gallery/image-gallery').NormalizedFileType | {
+                id: string | number;
+                extension: string;
+                icon?: string | undefined;
+                isImage: boolean;
+                name: string;
+                originalFile: {
+                    id: string | number;
+                    mimetype: string;
+                    type: string;
+                    original: {
+                        name: string;
+                        url: string;
+                    };
+                    thumbnail: {
+                        name: string;
+                        url: string;
+                    } | null;
+                    isHovered?: boolean | undefined;
+                } | {
+                    readonly lastModified: number;
+                    readonly name: string;
+                    readonly webkitRelativePath: string;
+                    readonly size: number;
+                    readonly type: string;
+                    arrayBuffer: () => Promise<ArrayBuffer>;
+                    bytes: () => Promise<Uint8Array<ArrayBuffer>>;
+                    slice: (start?: number, end?: number, contentType?: string) => Blob;
+                    stream: () => ReadableStream<Uint8Array<ArrayBuffer>>;
+                    text: () => Promise<string>;
+                };
+                type: string;
+                url: string;
+            } | null>;
+            hoveredIndex: import('vue').Ref<number | null | undefined, number | null | undefined>;
+            closeIconClasses: import('vue').ComputedRef<string[]>;
+            itemClasses: import('vue').ComputedRef<(string | {
+                animated: boolean;
+            })[]>;
+            images: import('vue').ComputedRef<any>;
+            normalizedFiles: import('vue').ComputedRef<any>;
+            thumbnailContainerClasses: import('vue').ComputedRef<(string | {
+                'flex-nowrap overflow-x-auto pt-2 -mt-2 pr-2': boolean;
+            })[]>;
+            downloadDocument: (file: import('../image-gallery/image-gallery').NormalizedFileType) => void;
+            getExtension: (fileName: string) => string;
+            onAttachmentClick: (file: any) => void;
+            onClickMenuLink: (action: any) => void;
+            onClickThumbnail: (index: any, file: any) => void;
+            onOpenCarousel: (index: number, file: import('../image-gallery/image-gallery').NormalizedFileType) => void;
+            onRemoveFile: (file?: import('../image-gallery/image-gallery').NormalizedFileType | null) => void;
+            onKeyboardNavigation: (e: any) => void;
+            onLongPressCallbackHook: (e: PointerEvent, index: any) => void;
+            resetHook: () => void;
+            mq: {
+                xs: boolean;
+                sm: boolean;
+                md: boolean;
+                lg: boolean;
+                xl: boolean;
+                'sm-md': boolean;
+                'md-lg': boolean;
+                'lg-xl': boolean;
+                'sm-down': boolean;
+            };
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("update:model-value" | "update:activeIndex" | "click:file")[], "update:model-value" | "update:activeIndex" | "click:file", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            id: {
+                type: StringConstructor;
+                default: string;
+            };
+            files: any;
+            thumbnailsVisible: {
+                type: NumberConstructor;
+                default: number;
+            };
+            showOnHover: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            showThumbnails: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            showRemove: {
+                type: PropType<boolean | number>;
+                default: boolean;
+            };
+            baseZIndex: {
+                type: NumberConstructor;
+                default: number;
+            };
+            wrap: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            processing: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{
+            "onUpdate:model-value"?: ((...args: any[]) => any) | undefined;
+            "onUpdate:activeIndex"?: ((...args: any[]) => any) | undefined;
+            "onClick:file"?: ((...args: any[]) => any) | undefined;
+        }>, {
+            wrap: boolean;
+            id: string;
+            thumbnailsVisible: number;
+            showOnHover: boolean;
+            showThumbnails: boolean;
+            showRemove: number | boolean;
+            baseZIndex: number;
+            processing: boolean;
+            files: any;
+        }, {}, {
+            Galleria: typeof import('primevue/galleria').default;
+            QBadge: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                color: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                shape: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>, {
+                bgColor: import('vue').ComputedRef<string>;
+                hasIcon: import('vue').ComputedRef<boolean>;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                color: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                shape: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>> & Readonly<{}>, {
+                color: string;
+                shape: string;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            QBottomSheet: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                modelValue: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                allowOnClickOutside: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                allowDrag: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                backgroundColor: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                setNoScroll: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                showCloseButton: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                topPosition: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                headerClass: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                titleClass: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                contentClass: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>, {
+                sheetRef: import('vue').Ref<any, any>;
+                headerRef: import('vue').Ref<any, any>;
+                windowHeight: import('vue').Ref<number, number>;
+                isDragging: import('vue').Ref<boolean, boolean>;
+                bgColor: import('vue').ComputedRef<string>;
+                containerClasses: import('vue').ComputedRef<"z-[201]" | "-z-40">;
+                show: import('vue').WritableComputedRef<boolean, boolean>;
+                hasHeaderAction: import('vue').ComputedRef<boolean>;
+                onClickOutside: () => void;
+                onClose: (option?: {
+                    clickOutside: boolean;
+                }) => Promise<void>;
+                onOpen: () => void;
+                dragHandler: (ctx: any) => void;
+                handleDrag: (ctx: any) => void;
+                handleDragEnd: (ctx: any) => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "update:model-value"[], "update:model-value", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                modelValue: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                allowOnClickOutside: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                allowDrag: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                backgroundColor: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                setNoScroll: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                showCloseButton: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                topPosition: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                headerClass: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                titleClass: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                contentClass: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>> & Readonly<{
+                "onUpdate:model-value"?: ((...args: any[]) => any) | undefined;
+            }>, {
+                modelValue: boolean;
+                contentClass: string;
+                backgroundColor: string;
+                allowOnClickOutside: boolean;
+                allowDrag: boolean;
+                setNoScroll: boolean;
+                showCloseButton: boolean;
+                topPosition: string;
+                headerClass: string;
+                titleClass: string;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            QMenu: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                modelValue: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                actions: {
+                    type: {
+                        (arrayLength: number): import('../..').MenuItem[];
+                        (...items: import('../..').MenuItem[]): import('../..').MenuItem[];
+                        new (arrayLength: number): import('../..').MenuItem[];
+                        new (...items: import('../..').MenuItem[]): import('../..').MenuItem[];
+                        isArray(arg: any): arg is any[];
+                        readonly prototype: any[];
+                        from<T>(arrayLike: ArrayLike<T>): T[];
+                        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        of<T>(...items: T[]): T[];
+                        readonly [Symbol.species]: ArrayConstructor;
+                    };
+                };
+                dismissibleOverlay: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                links: {
+                    type: {
+                        (arrayLength: number): import('../..').MenuItem[];
+                        (...items: import('../..').MenuItem[]): import('../..').MenuItem[];
+                        new (arrayLength: number): import('../..').MenuItem[];
+                        new (...items: import('../..').MenuItem[]): import('../..').MenuItem[];
+                        isArray(arg: any): arg is any[];
+                        readonly prototype: any[];
+                        from<T>(arrayLike: ArrayLike<T>): T[];
+                        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        of<T>(...items: T[]): T[];
+                        readonly [Symbol.species]: ArrayConstructor;
+                    };
+                    required: true;
+                };
+                linksBackground: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                overlay: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("click:link" | "click:action")[], "click:link" | "click:action", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                modelValue: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                actions: {
+                    type: {
+                        (arrayLength: number): import('../..').MenuItem[];
+                        (...items: import('../..').MenuItem[]): import('../..').MenuItem[];
+                        new (arrayLength: number): import('../..').MenuItem[];
+                        new (...items: import('../..').MenuItem[]): import('../..').MenuItem[];
+                        isArray(arg: any): arg is any[];
+                        readonly prototype: any[];
+                        from<T>(arrayLike: ArrayLike<T>): T[];
+                        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        of<T>(...items: T[]): T[];
+                        readonly [Symbol.species]: ArrayConstructor;
+                    };
+                };
+                dismissibleOverlay: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                links: {
+                    type: {
+                        (arrayLength: number): import('../..').MenuItem[];
+                        (...items: import('../..').MenuItem[]): import('../..').MenuItem[];
+                        new (arrayLength: number): import('../..').MenuItem[];
+                        new (...items: import('../..').MenuItem[]): import('../..').MenuItem[];
+                        isArray(arg: any): arg is any[];
+                        readonly prototype: any[];
+                        from<T>(arrayLike: ArrayLike<T>): T[];
+                        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        of<T>(...items: T[]): T[];
+                        readonly [Symbol.species]: ArrayConstructor;
+                    };
+                    required: true;
+                };
+                linksBackground: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                overlay: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>> & Readonly<{
+                "onClick:link"?: ((...args: any[]) => any) | undefined;
+                "onClick:action"?: ((...args: any[]) => any) | undefined;
+            }>, {
+                modelValue: boolean;
+                overlay: string;
+                dismissibleOverlay: boolean;
+                linksBackground: string;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            QPdfViewer: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                url: {
+                    type: StringConstructor;
+                    required: true;
+                };
+            }>, {
+                skeletonColumns: number;
+                skeletonRows: number;
+                canvasRefs: import('vue').Ref<(HTMLCanvasElement | null)[], (HTMLCanvasElement | null)[]>;
+                loadingMeta: import('vue').Ref<boolean, boolean>;
+                showErrorModal: import('vue').Ref<boolean, boolean>;
+                totalPages: import('vue').Ref<number, number>;
+                loadPDF: () => Promise<void>;
+                renderPage: (pageNumber: number) => Promise<void>;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "pdf-error"[], "pdf-error", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                url: {
+                    type: StringConstructor;
+                    required: true;
+                };
+            }>> & Readonly<{
+                "onPdf-error"?: ((...args: any[]) => any) | undefined;
+            }>, {}, {}, {
+                QErrorModal: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                    toggle: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                        required: true;
+                    };
+                }>, {
+                    toggleModal: import('vue').WritableComputedRef<boolean, boolean>;
+                    mq: {
+                        xs: boolean;
+                        sm: boolean;
+                        md: boolean;
+                        lg: boolean;
+                        xl: boolean;
+                        'sm-md': boolean;
+                        'md-lg': boolean;
+                        'lg-xl': boolean;
+                        'sm-down': boolean;
+                    };
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "update:toggle"[], "update:toggle", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                    toggle: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                        required: true;
+                    };
+                }>> & Readonly<{
+                    "onUpdate:toggle"?: ((...args: any[]) => any) | undefined;
+                }>, {}, {}, {
+                    QModal: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                        id: {
+                            type: StringConstructor;
+                            default: string;
+                        };
+                        closeButtonClass: {
+                            type: StringConstructor;
+                            default: string;
+                        };
+                        containerClass: {
+                            type: StringConstructor;
+                            default: string;
+                        };
+                        dismissible: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        dismissibleOverlay: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        dismissText: {
+                            type: StringConstructor;
+                            default: string;
+                        };
+                        overlay: {
+                            type: StringConstructor;
+                            default: string;
+                        };
+                        size: {
+                            type: StringConstructor;
+                            default: string;
+                        };
+                        showCancelLink: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        hasBuildingBg: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                    }>, {
+                        onCloseModal: () => void;
+                    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "close"[], "close", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                        id: {
+                            type: StringConstructor;
+                            default: string;
+                        };
+                        closeButtonClass: {
+                            type: StringConstructor;
+                            default: string;
+                        };
+                        containerClass: {
+                            type: StringConstructor;
+                            default: string;
+                        };
+                        dismissible: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        dismissibleOverlay: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        dismissText: {
+                            type: StringConstructor;
+                            default: string;
+                        };
+                        overlay: {
+                            type: StringConstructor;
+                            default: string;
+                        };
+                        size: {
+                            type: StringConstructor;
+                            default: string;
+                        };
+                        showCancelLink: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        hasBuildingBg: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                    }>> & Readonly<{
+                        onClose?: ((...args: any[]) => any) | undefined;
+                    }>, {
+                        size: string;
+                        overlay: string;
+                        id: string;
+                        dismissibleOverlay: boolean;
+                        closeButtonClass: string;
+                        containerClass: string;
+                        dismissible: boolean;
+                        dismissText: string;
+                        showCancelLink: boolean;
+                        hasBuildingBg: boolean;
+                    }, {}, {
+                        QIcon: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                            icon: {
+                                type: StringConstructor;
+                                required: true;
+                            };
+                            type: {
+                                type: StringConstructor;
+                                default: string;
+                            };
+                            width: {
+                                type: NumberConstructor;
+                                default: number;
+                                required: false;
+                            };
+                            height: {
+                                type: NumberConstructor;
+                                default: number;
+                                required: false;
+                            };
+                            size: {
+                                type: StringConstructor;
+                                default: string;
+                            };
+                            color: {
+                                type: StringConstructor;
+                                default: string;
+                            };
+                            inline: {
+                                type: BooleanConstructor;
+                                default: boolean;
+                            };
+                            customClass: {
+                                type: StringConstructor;
+                                default: string;
+                            };
+                            customSize: {
+                                type: BooleanConstructor;
+                                default: boolean;
+                            };
+                        }>, {
+                            iconPath: import('vue').ComputedRef<string>;
+                            customizedSize: import('vue').ComputedRef<boolean>;
+                        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                            icon: {
+                                type: StringConstructor;
+                                required: true;
+                            };
+                            type: {
+                                type: StringConstructor;
+                                default: string;
+                            };
+                            width: {
+                                type: NumberConstructor;
+                                default: number;
+                                required: false;
+                            };
+                            height: {
+                                type: NumberConstructor;
+                                default: number;
+                                required: false;
+                            };
+                            size: {
+                                type: StringConstructor;
+                                default: string;
+                            };
+                            color: {
+                                type: StringConstructor;
+                                default: string;
+                            };
+                            inline: {
+                                type: BooleanConstructor;
+                                default: boolean;
+                            };
+                            customClass: {
+                                type: StringConstructor;
+                                default: string;
+                            };
+                            customSize: {
+                                type: BooleanConstructor;
+                                default: boolean;
+                            };
+                        }>> & Readonly<{}>, {
+                            type: string;
+                            color: string;
+                            size: string;
+                            height: number;
+                            width: number;
+                            inline: boolean;
+                            customClass: string;
+                            customSize: boolean;
+                        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+                    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+                }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            QTooltip: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                id: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                color: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                controlled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                noWrap: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                position: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                relative: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                teleport: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                teleportTo: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                tooltipClasses: {
+                    type: (StringConstructor | ArrayConstructor | ObjectConstructor)[];
+                    default: string;
+                };
+                visible: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {
+                tooltipStyle: import('vue').Ref<{
+                    top: string;
+                    left: string;
+                }, {
+                    top: string;
+                    left: string;
+                } | {
+                    top: string;
+                    left: string;
+                }>;
+                tooltipTarget: import('vue').Ref<HTMLDivElement | null, HTMLDivElement | null>;
+                isVisible: import('vue').ComputedRef<boolean>;
+                hideTooltip: () => void;
+                showTooltip: () => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                id: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                color: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                controlled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                noWrap: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                position: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                relative: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                teleport: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                teleportTo: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                tooltipClasses: {
+                    type: (StringConstructor | ArrayConstructor | ObjectConstructor)[];
+                    default: string;
+                };
+                visible: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                color: string;
+                position: string;
+                visible: boolean;
+                relative: boolean;
+                disabled: boolean;
+                id: string;
+                controlled: boolean;
+                noWrap: boolean;
+                teleport: boolean;
+                teleportTo: string;
+                tooltipClasses: string | Record<string, any> | unknown[];
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        QModal: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            id: {
+                type: StringConstructor;
+                default: string;
+            };
+            closeButtonClass: {
+                type: StringConstructor;
+                default: string;
+            };
+            containerClass: {
+                type: StringConstructor;
+                default: string;
+            };
+            dismissible: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            dismissibleOverlay: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            dismissText: {
+                type: StringConstructor;
+                default: string;
+            };
+            overlay: {
+                type: StringConstructor;
+                default: string;
+            };
+            size: {
+                type: StringConstructor;
+                default: string;
+            };
+            showCancelLink: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            hasBuildingBg: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, {
+            onCloseModal: () => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "close"[], "close", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            id: {
+                type: StringConstructor;
+                default: string;
+            };
+            closeButtonClass: {
+                type: StringConstructor;
+                default: string;
+            };
+            containerClass: {
+                type: StringConstructor;
+                default: string;
+            };
+            dismissible: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            dismissibleOverlay: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            dismissText: {
+                type: StringConstructor;
+                default: string;
+            };
+            overlay: {
+                type: StringConstructor;
+                default: string;
+            };
+            size: {
+                type: StringConstructor;
+                default: string;
+            };
+            showCancelLink: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            hasBuildingBg: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{
+            onClose?: ((...args: any[]) => any) | undefined;
+        }>, {
+            size: string;
+            overlay: string;
+            id: string;
+            dismissibleOverlay: boolean;
+            closeButtonClass: string;
+            containerClass: string;
+            dismissible: boolean;
+            dismissText: string;
+            showCancelLink: boolean;
+            hasBuildingBg: boolean;
+        }, {}, {
+            QIcon: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                icon: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                type: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                width: {
+                    type: NumberConstructor;
+                    default: number;
+                    required: false;
+                };
+                height: {
+                    type: NumberConstructor;
+                    default: number;
+                    required: false;
+                };
+                size: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                color: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                inline: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                customClass: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                customSize: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {
+                iconPath: import('vue').ComputedRef<string>;
+                customizedSize: import('vue').ComputedRef<boolean>;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                icon: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                type: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                width: {
+                    type: NumberConstructor;
+                    default: number;
+                    required: false;
+                };
+                height: {
+                    type: NumberConstructor;
+                    default: number;
+                    required: false;
+                };
+                size: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                color: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                inline: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                customClass: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                customSize: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                type: string;
+                color: string;
+                size: string;
+                height: number;
+                width: number;
+                inline: boolean;
+                customClass: string;
+                customSize: boolean;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        QModalContent: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            useFlex: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            contentClass: {
+                type: StringConstructor;
+                default: string;
+            };
+            footerClass: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {
+            modalSize: unknown;
+            hasHeader: import('vue').ComputedRef<boolean>;
+            hasFooter: import('vue').ComputedRef<boolean>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            useFlex: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            contentClass: {
+                type: StringConstructor;
+                default: string;
+            };
+            footerClass: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{}>, {
+            contentClass: string;
+            useFlex: boolean;
+            footerClass: string;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default QWysiwyg;