@quoreadmin/ui 1.4.1 → 1.4.3

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

@@ -0,0 +1,1583 @@
+import { Args, Meta, StoryObj } from '@storybook/vue3';
+import { default as QWysiwyg } from './wysiwyg.vue';
+declare const meta: Meta<typeof QWysiwyg>;
+export default meta;
+type Story = StoryObj<typeof meta>;
+export declare const Primary: {
+    name: string;
+    render: (args: Args) => {
+        components: {
+            QWysiwyg: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                modelValue: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                attachments: {
+                    type: import('vue').PropType<File[]>;
+                    default: () => never[];
+                };
+                allowEmojis: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                allowAttachments: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                allowFormatting: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                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: import('vue').PropType<File[]>;
+                    default: () => never[];
+                };
+                allowEmojis: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                allowAttachments: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                allowFormatting: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                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: import('vue').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: import('vue').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: import('vue').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: import('vue').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: import('vue').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: import('vue').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: import('vue').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: import('vue').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>;
+        };
+        setup(this: void): {
+            args: Args;
+            textareaValue: import('vue').Ref<string, string>;
+            files: import('vue').Ref<never[], never[]>;
+        };
+        template: string;
+    };
+    args: {
+        allowAttachments: true;
+        allowFormatting: false;
+        allowEmojis: false;
+        filesAllowed: string;
+        isStacked: true;
+        placeholder: string;
+    };
+};
+export declare const Comment: Story;