@quoreadmin/ui 1.4.1 → 1.4.3

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

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