@quoreadmin/ui 1.4.1 → 1.4.3

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

@@ -0,0 +1,3157 @@
+import { PropType } from 'vue';
+import { FileType } from '../image-gallery/image-gallery';
+type Comment = {
+    attachments: FileType[];
+    comment: string;
+    dateLocal?: string;
+    dateShort?: string;
+    dateUtc?: string;
+    created?: {
+        dateUtc: string;
+        dateLocal: string;
+        dateShort: string;
+    };
+    edited?: {
+        dateUtc: string;
+        dateLocal: string;
+        dateShort: string;
+    };
+    id: number | string;
+    user: {
+        id: number | string;
+        name: string;
+    };
+    canDelete: number;
+    canEdit: number;
+};
+export type CommentType = Comment;
+declare const QComment: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    /** ID of the comment - maybe this will be in the data. We will need this for taking action on a comment */
+    readonly id: {
+        readonly type: PropType<number | string>;
+        readonly default: null;
+    };
+    readonly attachments: {
+        readonly type: {
+            (arrayLength: number): FileType[];
+            (...items: FileType[]): FileType[];
+            new (arrayLength: number): FileType[];
+            new (...items: FileType[]): FileType[];
+            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;
+        };
+        readonly default: readonly [];
+    };
+    readonly attachmentClickEvent: {
+        readonly type: FunctionConstructor;
+        readonly default: () => void;
+    };
+    readonly attachmentRemoveEvent: {
+        readonly type: FunctionConstructor;
+        readonly default: () => void;
+    };
+    /** Copy link option */
+    readonly canCopyLink: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    /** Delete option */
+    readonly canDelete: {
+        readonly type: PropType<boolean | number>;
+        readonly default: false;
+    };
+    /** Edit option */
+    readonly canEdit: {
+        readonly type: PropType<boolean | number>;
+        readonly default: false;
+    };
+    /** Pin option */
+    readonly canPin: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    /** User object to populate user related information */
+    readonly user: {
+        readonly type: ObjectConstructor;
+        readonly default: null;
+    };
+    readonly comment: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    /** Comment timestamp  OLD: timestamp */
+    readonly dateUtc: {
+        readonly type: PropType<string>;
+        readonly default: null;
+    };
+    readonly dateLocal: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly created: {
+        readonly type: ObjectConstructor;
+        readonly default: null;
+    };
+    readonly edited: {
+        readonly type: ObjectConstructor;
+        readonly default: null;
+    };
+    readonly onUpdateComment: {
+        readonly type: FunctionConstructor;
+        readonly default: () => void;
+    };
+    readonly pinned: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly processing: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly showAvatar: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly showRemoveButton: {
+        readonly type: ObjectConstructor;
+        readonly default: () => void;
+    };
+}>, {
+    menuActions: {
+        text: string;
+    }[];
+    activeAttachment: import('vue').Ref<{
+        id: string | number;
+        mimetype: string;
+        type: string;
+        original: {
+            name: string;
+            url: string;
+        };
+        thumbnail: {
+            name: string;
+            url: string;
+        } | null;
+        isHovered?: boolean | undefined;
+    } | null, FileType | {
+        id: string | number;
+        mimetype: string;
+        type: string;
+        original: {
+            name: string;
+            url: string;
+        };
+        thumbnail: {
+            name: string;
+            url: string;
+        } | null;
+        isHovered?: boolean | undefined;
+    } | null>;
+    editMode: import('vue').Ref<boolean, boolean>;
+    editText: import('vue').Ref<string, string>;
+    showControls: import('vue').Ref<boolean, boolean>;
+    warningAction: import('vue').Ref<boolean, boolean>;
+    warningModal: import('vue').Ref<boolean, boolean>;
+    warningType: import('vue').Ref<string, string>;
+    wysiwygRef: import('vue').Ref<any, any>;
+    allowedActions: import('vue').ComputedRef<any[]>;
+    displayName: import('vue').ComputedRef<string>;
+    formatDate: import('vue').ComputedRef<string>;
+    userInitials: import('vue').ComputedRef<string>;
+    onClickCancel: () => void;
+    onClickCopyLink: () => void;
+    onClickDeleteAttachment: (attachment: any) => void;
+    onClickDeleteAttachmentConfirm: () => Promise<void>;
+    onClickDeleteComment: () => void;
+    onClickDeleteCommentConfirm: () => Promise<void>;
+    onClickDeleteConfirm: () => void;
+    onClickEditComment: () => Promise<void>;
+    onClickMenu: () => void;
+    onClickMobileMenuLink: (action: any) => void;
+    onClickSave: () => Promise<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:model-value", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    /** ID of the comment - maybe this will be in the data. We will need this for taking action on a comment */
+    readonly id: {
+        readonly type: PropType<number | string>;
+        readonly default: null;
+    };
+    readonly attachments: {
+        readonly type: {
+            (arrayLength: number): FileType[];
+            (...items: FileType[]): FileType[];
+            new (arrayLength: number): FileType[];
+            new (...items: FileType[]): FileType[];
+            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;
+        };
+        readonly default: readonly [];
+    };
+    readonly attachmentClickEvent: {
+        readonly type: FunctionConstructor;
+        readonly default: () => void;
+    };
+    readonly attachmentRemoveEvent: {
+        readonly type: FunctionConstructor;
+        readonly default: () => void;
+    };
+    /** Copy link option */
+    readonly canCopyLink: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    /** Delete option */
+    readonly canDelete: {
+        readonly type: PropType<boolean | number>;
+        readonly default: false;
+    };
+    /** Edit option */
+    readonly canEdit: {
+        readonly type: PropType<boolean | number>;
+        readonly default: false;
+    };
+    /** Pin option */
+    readonly canPin: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    /** User object to populate user related information */
+    readonly user: {
+        readonly type: ObjectConstructor;
+        readonly default: null;
+    };
+    readonly comment: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    /** Comment timestamp  OLD: timestamp */
+    readonly dateUtc: {
+        readonly type: PropType<string>;
+        readonly default: null;
+    };
+    readonly dateLocal: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly created: {
+        readonly type: ObjectConstructor;
+        readonly default: null;
+    };
+    readonly edited: {
+        readonly type: ObjectConstructor;
+        readonly default: null;
+    };
+    readonly onUpdateComment: {
+        readonly type: FunctionConstructor;
+        readonly default: () => void;
+    };
+    readonly pinned: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly processing: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly showAvatar: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly showRemoveButton: {
+        readonly type: ObjectConstructor;
+        readonly default: () => void;
+    };
+}>> & Readonly<{
+    "onUpdate:model-value"?: ((...args: any[]) => any) | undefined;
+}>, {
+    readonly id: string | number;
+    readonly created: Record<string, any>;
+    readonly processing: boolean;
+    readonly attachments: FileType[];
+    readonly attachmentClickEvent: Function;
+    readonly attachmentRemoveEvent: Function;
+    readonly canCopyLink: boolean;
+    readonly canDelete: number | boolean;
+    readonly canEdit: number | boolean;
+    readonly canPin: boolean;
+    readonly user: Record<string, any>;
+    readonly comment: string;
+    readonly dateUtc: string;
+    readonly dateLocal: string;
+    readonly edited: Record<string, any>;
+    readonly onUpdateComment: Function;
+    readonly pinned: boolean;
+    readonly showAvatar: boolean;
+    readonly showRemoveButton: Record<string, any>;
+}, {}, {
+    QAvatar: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        size: {
+            type: StringConstructor;
+            default: string;
+        };
+        text: {
+            type: StringConstructor[];
+            default: string;
+        };
+        bgColor: {
+            type: StringConstructor;
+            default: string;
+        };
+        src: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>, {
+        validSrc: import('vue').Ref<boolean, boolean>;
+        isLoaded: import('vue').Ref<boolean, boolean>;
+        onImageLoad: () => void;
+        onImageError: () => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        size: {
+            type: StringConstructor;
+            default: string;
+        };
+        text: {
+            type: StringConstructor[];
+            default: string;
+        };
+        bgColor: {
+            type: StringConstructor;
+            default: string;
+        };
+        src: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>> & Readonly<{}>, {
+        text: string;
+        size: string;
+        bgColor: string;
+        src: 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>;
+    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>;
+    QPopover: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        align: {
+            type: StringConstructor;
+            default: string;
+        };
+        hasCaret: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        modelValue: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        position: {
+            type: StringConstructor;
+            default: string;
+        };
+        reposition: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        size: {
+            type: StringConstructor;
+            default: string;
+        };
+        trigger: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>, {
+        entered: import('vue').Ref<boolean, boolean>;
+        offsetStyle: import('vue').Ref<string, string>;
+        popover: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+        alignment: import('vue').ComputedRef<string>;
+        positioning: import('vue').ComputedRef<string>;
+        getAlignment: (align: string) => string;
+        getPositioning: (position: string) => string;
+        isElementInView: (ele: any) => boolean;
+        onAfterLeave: () => void;
+        onClick: () => void;
+        onClickOutside: typeof import('@vueuse/core').onClickOutside;
+        onEnter: () => void;
+        onMouseLeave: () => void;
+        onMouseOver: () => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        align: {
+            type: StringConstructor;
+            default: string;
+        };
+        hasCaret: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        modelValue: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        position: {
+            type: StringConstructor;
+            default: string;
+        };
+        reposition: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        size: {
+            type: StringConstructor;
+            default: string;
+        };
+        trigger: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>> & Readonly<{
+        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+    }>, {
+        modelValue: boolean;
+        size: string;
+        position: string;
+        trigger: string;
+        align: string;
+        hasCaret: boolean;
+        reposition: boolean;
+    }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    QWarningModal: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        toggle: {
+            type: BooleanConstructor;
+            default: boolean;
+            required: true;
+        };
+        action: {
+            type: FunctionConstructor;
+            default: () => void;
+        };
+        processing: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>, {
+        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:action")[], "update:toggle" | "update:action", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        toggle: {
+            type: BooleanConstructor;
+            default: boolean;
+            required: true;
+        };
+        action: {
+            type: FunctionConstructor;
+            default: () => void;
+        };
+        processing: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{
+        "onUpdate:toggle"?: ((...args: any[]) => any) | undefined;
+        "onUpdate:action"?: ((...args: any[]) => any) | undefined;
+    }>, {
+        action: Function;
+        processing: boolean;
+    }, {}, {
+        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>;
+    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;
+        };
+        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;
+        };
+        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>;
+}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export type QCommentType = typeof QComment;
+export default QComment;