@evercam/ui 0.0.61 → 0.0.63-Add-timeline-test-2d1f69478

package/dist/index.d.ts

@@ -1,3 +1,1175 @@
-export * from './src/index'
-import EvercamUI from './src/index'
-export default EvercamUI
+import EAvatar from './components/EAvatar.vue';
+import EBadge from './components/EBadge.vue';
+import EIcon from './components/EIcon.vue';
+import ESpinner from './components/ESpinner.vue';
+import ERow from './components/ERow.vue';
+import ECol from './components/ECol.vue';
+import EVideoPlayer from './components/EVideoPlayer.vue';
+import ETimeline from './components/timeline/ETimeline.vue';
+import EVideoEmbed from './components/EVideoEmbed.vue';
+import EHeatmapBar from './components/EHeatmapBar.vue';
+import EHoursHeatmap from './components/EHoursHeatmap.vue';
+import EReadMore from './components/EReadMore.vue';
+import ETruncatedDiv from './components/ETruncatedDiv.vue';
+import ECompareSeparator from './components/ECompareSeparator.vue';
+import EImagesComparator from './components/EImagesComparator.vue';
+import EExpandableMenu from './components/EExpandableMenu.vue';
+import ESvgIcon from './components/ESvgIcon.vue';
+import ECalendarHeatmap from './components/ECalendarHeatmap.vue';
+import EFlagIcon from './components/EFlagIcon.vue';
+import EToggleSwitch from './components/EToggleSwitch.vue';
+import EZoomable from './components/EZoomable.vue';
+import { VueConstructor } from "vue";
+import EGlobalSearch from './components/EGlobalSearch.vue';
+import EImagePlayer from "./components/EImagePlayer.vue";
+import EZoomableImg from "./components/EZoomableImg.vue";
+import EZoomSlider from "./components/EZoomSlider.vue";
+import EActionButton from "./components/EActionButton.vue";
+import ETooltip from "./components/ETooltip.vue";
+import ELayout from "./components/ELayout.vue";
+import ECopyToClipboardBtn from "./components/ECopyToClipboardBtn.vue";
+export declare const components: {
+    EAvatar: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {
+        sizes: {
+            "2xs": string;
+            xs: string;
+            sm: string;
+            base: string;
+            lg: string;
+            xl: string;
+            "2xl": string;
+        };
+    }, unknown, {
+        avatarClasses: string[];
+    }, {
+        size: import('./types').Size;
+        showBadge: boolean;
+        badgeColor: import('./types').BaseColor;
+        badgeText: string;
+        badgeSize: import('./types').Size;
+        image: string;
+        backgroundClasses: string;
+    }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+    EBadge: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {
+        colors: {
+            error: string;
+            info: string;
+            warning: string;
+            primary: string;
+            default: string;
+            success: string;
+        };
+        sizes: {
+            dot: string;
+            xs: string;
+            sm: string;
+            base: string;
+            lg: string;
+            xl: string;
+        };
+    }, unknown, {
+        badgeClasses: string[];
+        showText: boolean;
+    }, {
+        text: string;
+        color: import('./types').BaseColor;
+        size: import('./types').Size;
+    }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+    EIcon: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, unknown, unknown, {
+        sizes: Record<import('./types').Size, string>;
+        iconClasses: string[];
+    }, {
+        icon: string;
+        color: string;
+        size: import('./types').Size;
+    }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+    ESpinner: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {
+        sizes: any;
+        colors: any;
+    }, {
+        getNthPathStyle(index: number): {
+            animationDuration: string;
+            animationDelay: string;
+            fill: string;
+        };
+    }, {
+        computedSize: number;
+        fill: {
+            primary: string;
+            secondary: string;
+        };
+    }, {
+        dark: boolean;
+        color: boolean;
+        animationDuration: string | number;
+        size: import('./types').Size;
+        opacity: string | number;
+    }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+    ERow: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, unknown, unknown, {
+        justifyClasses: Record<string, boolean>;
+        rowClasses: Record<string, boolean>;
+    }, {
+        align: import('./types').FlexAlignItems;
+        alignContent: import('./types').FlexAlignContent;
+        justify: import('./types').FlexJustifyContent;
+        justifyXs: import('./types').FlexJustifyContent;
+        justifySm: import('./types').FlexJustifyContent;
+        justifyMd: import('./types').FlexJustifyContent;
+        justifyLg: import('./types').FlexJustifyContent;
+        justifyXl: import('./types').FlexJustifyContent;
+        noGutters: boolean;
+    }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+    ECol: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, unknown, {
+        autoClasses(prefix: string, value: string | number | boolean): string;
+        isSizePropAuto(prop: string | number | boolean | undefined, acceptUndefined?: boolean): boolean;
+        isSizePropertyNumeric(prop: string | number | boolean | undefined): boolean;
+    }, {
+        colClasses: Record<string, boolean>;
+    }, {
+        alignSelf: string;
+        cols: string | number | boolean;
+        lg: string | number | boolean;
+        md: string | number | boolean;
+        offset: string | number;
+        offsetLg: string | number;
+        offsetMd: string | number;
+        offsetSm: string | number;
+        offsetXs: string | number;
+        offsetXl: string | number;
+        sm: string | number | boolean;
+        xs: string | number | boolean;
+        xl: string | number | boolean;
+    }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+    EVideoPlayer: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {
+        playing: boolean;
+        percentagePlayed: number;
+        videoLength: string;
+        duration: number;
+        videoDuration: number;
+        currentTime: string;
+        realtime: number;
+        isScrubbing: boolean;
+        wasPaused: boolean;
+        isFullscreen: boolean;
+        isFinished: boolean;
+        isLoading: boolean;
+        isError: boolean;
+        player: import("hls.js").default;
+        playbackRetries: number;
+        preloadedSeconds: number;
+        preloadedInterval: {
+            start: string;
+            end: string;
+        };
+    }, {
+        initHls(src?: string): void;
+        onContainerClick(): void;
+        handle404Error(): void;
+        handleHlsError(_: import("hls.js").Events.ERROR, data: import("hls.js").ErrorData): void;
+        bindEvents(): void;
+        onProgress(): void;
+        unbindEvents(): void;
+        bindVideoEvent(which: string): void;
+        initializePlayer(): void;
+        destroyPlayer(): void;
+        removeFullscreenListeners(): void;
+        initializeFullscreenListeners(): void;
+        handleFullscreenChange(): void;
+        isLooped(): boolean;
+        handleScrubbingOnMouseEnd(e: MouseEvent): void;
+        handleEnded(): void;
+        handleLoading(): void;
+        play(): Promise<void>;
+        pause(): void;
+        togglePlay(): Promise<void>;
+        setPlaying(state: boolean): void;
+        seekToPercentage(percentage: number): void;
+        convertTimeToDuration(seconds: number): string;
+        closeFullscreenMode(): void;
+        openFullscreenMode(): void;
+        toggleFullscreenMode(): void;
+        getDuration(): void;
+        handleTimeUpdate(): void;
+        handleTimelineUpdate(e: MouseEvent): void;
+        skip(duration?: number): void;
+        toggleScrubbing(e: MouseEvent): Promise<void>;
+        handleKeyDown(e: KeyboardEvent): void;
+    }, {
+        posterUrl: string;
+        sourceItems: import('./components/EVideoPlayer.vue').VideoSource[];
+        withControls: "" | "hide";
+    }, {
+        targetTimestamp: string;
+        sources: string | import('./components/EVideoPlayer.vue').VideoSource[];
+        videoListeners: {};
+        videoOptions: {};
+        isHls: boolean;
+        streamingToken: string;
+        pauseOnClick: boolean;
+        isHlsLoading: boolean;
+        isPlaying: boolean;
+        isZoomable: boolean;
+        zoomableIgnorePointerEvents: boolean;
+        timezone: string;
+        playPauseAnimation: boolean;
+        disablePlayPauseAnimation: boolean;
+        isWebRtc: boolean;
+        withColoredLoader: boolean;
+        loaderSize: string;
+        withOverlayOnBackground: boolean;
+        fallbackSrc: string;
+        hlsOptions: {};
+    }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+    ETimeline: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {
+        mainContainer: HTMLElement;
+        tooltip: HTMLElement;
+        timeline: HTMLElement;
+        wrapperDiv: HTMLElement;
+        svgElement: SVGSVGElement;
+        svg: import("d3-selection").Selection<SVGSVGElement, any, any, any>;
+        timeScale: import("d3-scale").ScaleTime<any, any, unknown>;
+        currentTimeScaleDensity: number;
+        axisHeight: number;
+        isHoveringEvent: boolean;
+        hoveredEvent: import('./types').TimelineEvent;
+        eventTooltipStyle: {};
+        hoveredEventType: string;
+        utcOffset: number;
+        yScale: import("d3-scale").ScaleLinear<any, any, never>;
+        hoveredCounts: {
+            count: number;
+            type: string;
+            label?: string | undefined;
+        }[];
+        countsByTimestamp: Record<string, Record<string, number>>;
+        dotsByTimestamp: Record<string, import("d3-selection").Selection<SVGCircleElement, any, any, any>[]>;
+        visibleFrom: Date;
+        visibleTo: Date;
+        curtainHandleWidth: number;
+        leftCurtainWidth: number;
+        rightCurtainWidth: number;
+        isHoveringCurtain: boolean;
+        isDraggingCurtain: boolean;
+        characterWidth: number;
+        textPadding: number;
+        debouncedOnResize: Function;
+        isFirstPaint: boolean;
+        timeouts: number[];
+        groupsVisibility: Record<string, boolean>;
+        selectedMilestoneId: any;
+        isInitialized: boolean;
+        transformDiff: {
+            translation: number;
+            scale: number;
+        };
+        isZoomingInterval: boolean;
+        hoveredMilestone: import('./types').TimelineEvent;
+        focusedDomain: import('./types').TimelineDomain;
+        transitionDuration: number;
+        focusedTimestamp: string | Date;
+    }, {
+        validateProps(): void;
+        updateTimeline(): void;
+        initTimeline(): void;
+        initRefs(): void;
+        initOrUpdateSvg(): void;
+        initUtcOffset(): void;
+        initYScale(): void;
+        updateYScale(): void;
+        zoomToFitMarkers(): void;
+        selectOrAppend({ parent, targetId, targetType, }: {
+            parent: import("d3-selection").Selection<any, any, any, any>;
+            targetId: string;
+            targetType: string;
+        }): import("d3-selection").Selection<import("d3-selection").BaseType, any, any, any>;
+        clearTimeline(): void;
+        updateCurrentTimeScaleDensity(): void;
+        emitVisibleInterval(trigger: import('./types').TimelineIntervalChangeTrigger): void;
+        onResize(resizeObserverEntry: ResizeObserverEntry): void;
+        handleResize({ contentRect }: ResizeObserverEntry): void;
+        handleDarkModeChange(): void;
+        handleMouseLeave(): void;
+        handleMouseMove(mouseX: number, timestamp: string): void;
+        handleClick(timestamp: string, target: HTMLElement): void;
+        handleMarkerClick(marker: import('./types').TimelineMarker): void;
+        handleLineMouseOver(_event: MouseEvent, eventData: import('./types').TimelineCountEvent, eventType: string): void;
+        handleLineMouseOut(): void;
+        handleBarMouseOver(event: MouseEvent, eventData: import('./types').TimelineEvent, eventType: string): void;
+        handleBarMouseOut(): void;
+        handleLabelMouseOver(groupType: string): void;
+        handleLabelMouseLeave(groupType: string): void;
+        handleTransformChange(transform: {
+            translation: number;
+            scale: number;
+        }): void;
+        handleTimeScaleChange(ts: import("d3-scale").ScaleTime<any, any, unknown>): void;
+        emitCurtainChange(): void;
+        calculateDateRangeFromCurtains(): {
+            startDate: Date;
+            endDate: Date;
+        };
+        handleDragStart(): void;
+        handleDragEnd(): void;
+        handleLeftDrag(event: import("d3-drag").D3DragEvent<SVGRectElement, any, any>): void;
+        handleRightDrag(event: import("d3-drag").D3DragEvent<SVGRectElement, any, any>): void;
+        zoomToStartAndEndDates(): void;
+        updateEventsBars(): void;
+        updateBarChart(): void;
+        updateLineGraphs(): void;
+        updateLineGraphHoverZones(): void;
+        getEventRectX(d: import('./types').TimelineEvent): any;
+        getEventRectWidth(d: import('./types').TimelineEvent): number;
+        getEventText(e: import('./types').TimelineEvent): string;
+        getElementLeftPosition(element: HTMLElement): number;
+        initCurtains(): void;
+        createCurtains(): void;
+        updateCurtains(): void;
+        updateForbiddenIntervals(reset?: boolean): void;
+        drawEventsGroups(): void;
+        drawLineGraphEventsGroups(): void;
+        drawLineGraph({ events, gElement, color, type, }: {
+            events: import('./types').TimelineEvent[];
+            gElement: import("d3-selection").Selection<SVGGElement, any, any, any>;
+            color: string;
+            type: string;
+        }): void;
+        drawLineGraphHoverZones({ events, gElement, color, type, }: {
+            events: import('./types').TimelineCountEvent[];
+            gElement: import("d3-selection").Selection<SVGGElement, any, any, any>;
+            color: string;
+            type: string;
+        }): void;
+        drawSingleBarEventsGroup({ type, eventsGroup, milestone, dots, dotsSize, bottom, }: {
+            type: string;
+            eventsGroup: import('./types').TimelineEventsGroup;
+            milestone?: boolean | undefined;
+            dots?: boolean | undefined;
+            dotsSize?: number | undefined;
+            bottom?: boolean | undefined;
+        }): void;
+        drawBarEventsGroups(): void;
+        drawMilestonesPlaceholder(): void;
+        getMilestoneClass(milestone: import('./types').TimelineEvent): Record<string, boolean>;
+        getMilestoneColors(milestoneColor: string | undefined, groupColor: string): {
+            background: string;
+            border: string;
+        };
+        getMilestoneGroupYPosition(groupName: string): number;
+        getBarGroupYPosition(groupName: string, bottom?: boolean | undefined): number;
+        getBarGroupHeight(eventsGroup: import('./types').TimelineEventsGroup): number;
+        updateMilestonesPositions(): void;
+        drawBarChartEventsGroups(): void;
+        drawProgressIndicator({ yPosition, type, isLoading, }: {
+            yPosition: number;
+            type: string;
+            color: string;
+            isLoading: Boolean | undefined;
+        }): void;
+        drawBackground({ color, yPosition, gElement, height, }: {
+            gElement: import("d3-selection").Selection<SVGGElement, any, any, any>;
+            yPosition: number;
+            color: string;
+            height?: number | undefined;
+        }): void;
+        drawBars({ events, gElement, yPosition, color, type, dots, dotsSize, height, barBorderRadius, }: {
+            events: import('./types').TimelineEvent[];
+            gElement: import("d3-selection").Selection<SVGGElement, any, any, any>;
+            yPosition: number;
+            color: string;
+            type: string;
+            dots?: boolean | undefined;
+            dotsSize?: number | undefined;
+            height?: number | undefined;
+            barBorderRadius?: number | undefined;
+        }): void;
+        drawBarsChart({ events, gElement, color, yOffset, type, index, }: {
+            events: import('./types').TimelineEvent[];
+            gElement: import("d3-selection").Selection<SVGGElement, any, any, any>;
+            color: string;
+            yOffset: number;
+            type: string;
+            index: number;
+        }): void;
+        onBarChartBarMouseOver(container: import("d3-selection").Selection<SVGGElement, any, any, any>, color: string): void;
+        onBarChartBarMouseOut(container: import("d3-selection").Selection<SVGGElement, any, any, any>, eventType: string): void;
+        drawTextLabel({ gElement, yPosition, color, label, type, height, }: {
+            gElement: import("d3-selection").Selection<SVGGElement, any, any, any>;
+            yPosition: number;
+            color: string;
+            label: string;
+            type: string;
+            height?: number | undefined;
+        }): void;
+        getTextFillColor(baseColor: string, k?: number): string;
+        getLabelBackgroundColor(baseColor: string): string;
+        getCurrentGroupVisibility(type: string): boolean;
+        toggleGroupVisibility(type: string): void;
+        getExternalLabelStyles(type: string): {
+            background: string;
+            color: string;
+        };
+        getExternalLabelText(type: string): string;
+        getExternalLabelWrapperStyles(type: string): {
+            borderColor: string;
+        };
+        tzStringToDate(timestamp: import('./types').Timestamp): Date;
+        dateToTzString(date: Date): string;
+        getFormattedTimestamp(timestamp: import('./types').Timestamp): string;
+        fillTimeGaps(events: import('./types').TimelineEvent[]): (import('./types').TimelineBarEvent | import('./types').TimelineRangeEvent | import('./types').TimelineCountEvent | {
+            timestamp: string;
+            count: number;
+        })[];
+        fillEvents(events: import('./types').TimelineEvent[]): import('./types').TimelineEvent[];
+        onMilestoneClick(milestone: import('./types').TimelineEvent, milestoneType: any): void;
+        getSortedEvents(events: import('./types').TimelineEvent[]): import('./types').TimelineEvent[];
+        onHoverMilestone(milestone: import('./types').TimelineEvent): void;
+    }, {
+        combinedBarsHeight: number;
+        combinedBottomBarsHeight: number;
+        combinedMilestonesHeight: number;
+        milestonesYOffset: number;
+        chartsYOffset: number;
+        barsYOffset: number;
+        hasMilestones: boolean;
+        barChartHeight: number;
+        computedClasses: Record<string, string | Record<string, boolean>>;
+        lineGraphGroups: import('./types').TimelineEventsByType;
+        chartHeight: number;
+        barGroups: import('./types').TimelineEventsByType;
+        barChartGroups: import('./types').TimelineEventsByType;
+        milestonesGroups: import('./types').TimelineEventsByType;
+        hasChart: boolean;
+        labelRectWidth: number;
+        combinedXAxesHeight: number;
+        timelineWidth: number;
+        timelineHeight: number;
+        filteredEventsGroups: import('./types').TimelineEventsByType;
+        allEventsSorted: import('./types').TimelineEvent[];
+        oldestEvent: import('./types').TimelineEvent;
+        latestEvent: import('./types').TimelineEvent;
+        allLineChartTimestamps: string[];
+        placeholderLineChartGroup: import('./types').TimelineEvent[];
+        filledGapsLineGraphGroups: import('./types').TimelineEventsByType;
+        isInteractingWithCurtain: boolean;
+        flattenedCounts: import('./types').TimelineCountEvent[];
+        hiddenGroupsLabels: string[];
+        minHoverZone: number;
+        sortedMarkers: import('./types').TimelineMarker[];
+        maxVisibleCount: number;
+        defaultMaxDomain: string[];
+        defaultFocusedDomain: string[];
+        domain: import('./types').TimelineDomain;
+        svgLeft: number;
+        markersScopedSlots: Record<string, import("vue/types/vnode").NormalizedScopedSlot | undefined>;
+        isHoveringMilestone: Boolean;
+    }, {
+        eventsGroups: import('./types').TimelineEventsByType;
+        dark: boolean;
+        startDate: string;
+        endDate: string;
+        selectedTimestamp: string;
+        showEventTooltip: boolean;
+        disableZoom: boolean;
+        insertZerosAtInterval: import('./types').TimelinePrecision;
+        flattenLineGraphEnds: boolean;
+        curtains: boolean;
+        showLabels: boolean;
+        rectMinWidth: number;
+        barHeight: number;
+        barYPadding: number;
+        barXPadding: number;
+        chartMinHeight: number;
+        chartMinLabelHeight: number;
+        minDate: string;
+        maxDate: string;
+        selectedClass: string | undefined;
+        panOnDateClick: boolean;
+        panTransitionDuration: number;
+        selectedDate: string;
+        autoResize: boolean;
+        markers: import('./types').TimelineMarker[];
+        stickyMarkers: boolean;
+        fitMarkersOnChange: boolean;
+        zoomToIntervalTransitionDuration: number;
+        zoomToBoundariesTransitionDuration: number;
+        milestoneBulletSize: number;
+        milestonesFirst: boolean;
+        forbiddenIntervals: import('./types').TimelineInterval[];
+        forbiddenIntervalColor: string;
+        focusedInterval: import('./types').TimelineInterval | undefined;
+        locked: boolean;
+        timezone: string | undefined;
+        stopClickPropagation: boolean;
+        tooltipPosition: string;
+        maxDomainPadding: number;
+        showCursor: boolean;
+    }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+    EVideoEmbed: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, unknown, unknown, {
+        videoId: string | undefined;
+        embedUrl: string;
+    }, {
+        videoUrl: string;
+        platform: "youtube" | "vimeo";
+        iframeListeners: {};
+        iframeOptions: any;
+    }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+    EHeatmapBar: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {}, {
+        getColorIndex(count: number): number;
+        getColor(count: number): string;
+        getItemStyle(count: number): {
+            background: string;
+        };
+        getItemClasses(itemClass: string | Record<string, boolean>): Record<string, boolean>;
+        getCountTextStyle(count: number): {
+            color: string;
+        };
+        adjustColorBrightness(color: string, amount: number): string;
+        getContrastingPaletteColor(backgroundColor: string): string;
+    }, {
+        heatMapBarItems: import('./types').HeatmapBarItem[];
+        maxCount: number;
+        computedColors: string[];
+        textColor: Record<string, string>;
+    }, {
+        items: unknown[];
+        selectedValue: string | number;
+        showCounts: boolean;
+        namesOnly: boolean;
+        showNames: boolean;
+        colors: string[];
+        colorsDark: string[];
+        label: string;
+        dense: boolean;
+        dark: boolean;
+    }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+    EHoursHeatmap: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, unknown, {
+        getFormattedHour(h: number): string;
+    }, {
+        itemsByHour: Record<string, import('./types').HoursHeatmapChartItem>;
+        heatmapBarItems: any;
+    }, {
+        items: unknown[];
+        selectedHour: string | number;
+        showHours: boolean;
+        colors: unknown[];
+        label: string;
+        dense: boolean;
+    }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+    EReadMore: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {
+        showAllContent: boolean;
+    }, {
+        displayContent(): any;
+        displayArrayContent(): any;
+        displayTextContent(): string | unknown[] | (() => null);
+        toggleContentExpansion(): void;
+    }, {
+        hiddenContentLength: number;
+        isArrayContent: boolean;
+        isHiddenTextContent: boolean;
+        isHiddenArrayContent: boolean;
+        isContentExpanded: boolean;
+        computedMoreText: string;
+    }, {
+        content: string | unknown[] | (() => null);
+        maxLength: number;
+        showAll: boolean;
+        expandText: string;
+        collapseText: string;
+        moreTextWithPlaceholder: string;
+    }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+    ETruncatedDiv: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, unknown, unknown, {
+        containerStyle: Record<string, any>;
+    }, {
+        width: string | number;
+        fixedWidth: boolean;
+    }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+    ECompareSeparator: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, unknown, unknown, {
+        separatorStyle: Record<string, any>;
+    }, {
+        xOffset: string | number;
+    }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+    EImagesComparator: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {
+        separatorPositionX: number;
+        startSeparatorPositionX: number;
+        computedImageDimension: Record<string, any>;
+        isSeparatorDragging: boolean;
+        watermarkDimension: Record<string, any>;
+        touchIdentifier: number | null;
+        startTouchX: number;
+        containerRect: DOMRect;
+        container: HTMLElement;
+        afterImage: HTMLImageElement;
+    }, {
+        handleResize(): void;
+        handleWatermarkResize(): void;
+        handleMouseMove(event: MouseEvent): void;
+        handleMouseDown(): void;
+        handleMouseUp(): void;
+        handleTouchStart(event: TouchEvent): void;
+        handleTouchMove(event: TouchEvent): void;
+        handleTouchEnd(event: TouchEvent): void;
+    }, {
+        clipStyle: Record<string, string>;
+        contentStyle: Record<string, string>;
+        imageSizeClasses: "e-w-full e-h-full" | "e-w-0 e-h-0";
+    }, {
+        beforeImageSrc: string;
+        afterImageSrc: string;
+        isLoading: boolean;
+    }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+    EToggleSwitch: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, unknown, {
+        onValueChange(event: Event): void;
+        getButtonClasses(optionValue: any): {
+            "e-border-none": boolean;
+            "e-bg-inherit": boolean;
+            "e-bg-brand-600": boolean;
+            "e-bg-gray-600": boolean;
+            "e-bg-[#629efc] e-text-gray-900 e-font-normal": boolean;
+        };
+        handleClick(value: any): void;
+    }, {
+        sizeClasses: {
+            container: import('./components/EToggleSwitch.vue').CssClassMap;
+            button: import('./components/EToggleSwitch.vue').CssClassMap;
+            text: import('./components/EToggleSwitch.vue').CssClassMap;
+        };
+        containerClasses: import('./components/EToggleSwitch.vue').CssClassMap;
+        textClasses: import('./components/EToggleSwitch.vue').CssClassMap;
+        buttonBaseClasses: import('./components/EToggleSwitch.vue').CssClassMap;
+    }, {
+        options: import('./components/EToggleSwitch.vue').EToggleSwitchOption[];
+        color: string;
+        size: import('./types').Size;
+        defaultValue: string | number | boolean;
+        value: string | number | boolean;
+    }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+    EExpandableMenu: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {
+        menu: boolean;
+        touched: boolean;
+        baseSize: {};
+    }, {
+        toggleMenu(): void;
+        setButtonsPositions(open?: boolean | undefined): void;
+    }, {
+        row: boolean;
+        reverse: boolean;
+    }, {
+        padding: number;
+        direction: string;
+        isMobile: boolean;
+    }, {}, import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {
+        eventListeners: import("./mixins/event-listeners").IEventListener[];
+    }, {
+        $addEventListener(event: string, cb: () => void, element?: Window & typeof globalThis): void;
+        $removeEventListener(event: string, cb: () => void, element?: Window & typeof globalThis): void;
+        $removeEventListeners(): void;
+    }, unknown, Record<never, any>, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin> | import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {
+        timeouts: number[];
+    }, {
+        $setTimeout(cb: Function, timeout?: number): number;
+        $clearTimeouts(): void;
+    }, unknown, Record<never, any>, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>, import("vue").ComponentOptionsMixin>;
+    EZoomable: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {
+        scale: number;
+        minScale: number;
+        maxScale: number;
+        top: number;
+        left: number;
+        isPanning: boolean;
+        panStart: {
+            x: number;
+            y: number;
+        };
+        isPinching: boolean;
+        previousPinchDistance: number;
+        pinchDistance: number;
+        pointers: Record<number, PointerEvent>;
+        transform: string;
+    }, {
+        updateZoomScale(): void;
+        handleZoom(e: WheelEvent): void;
+        handleMouseDown(e: MouseEvent): void;
+        handleMouseUp(): void;
+        handleMouseLeave(): void;
+        handleMouseMove(e: MouseEvent): void;
+        applyBoundsCorrection(): void;
+        updateTransform(): void;
+        getPointersDistance(a: PointerEvent, b: PointerEvent): number;
+        getPointersMidPoint(a: PointerEvent, b: PointerEvent): {
+            x: number;
+            y: number;
+        };
+        updatePointerEvent(e: PointerEvent): void;
+        clearPointerEvent(e: PointerEvent): void;
+        updatePinchDistance(): void;
+        handlePointerDown(e: PointerEvent): void;
+        handlePointerMove(e: PointerEvent): void;
+        handlePointerUp(e: PointerEvent): void;
+    }, {
+        contentStyle: import("vue").StyleValue;
+        isZoomed: boolean;
+    }, {
+        ignorePointerEvents: boolean;
+        withOverlay: boolean;
+        disabled: boolean;
+    }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+    EGlobalSearch: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {
+        search: string;
+        isSearching: boolean;
+    }, {
+        onInput(event: InputEvent): void;
+        searchObjectsByQuery(objects: import('./types').GlobalSearchResultInput[], query: string): import('./types').GlobalSearchResult[];
+        findMatchesInObject(obj: import('./types').GlobalSearchResultInput, query: string, path: string[]): import('./types').GlobalSearchMatch[];
+        matchesQuery(value: any, query: string): boolean;
+        isValidDate(date: string | Date): boolean;
+        formattedTimestamp(timestamp: string): string;
+        onKeyHandler(event: unknown): void;
+    }, {
+        inputClasses: Record<string, boolean>;
+    }, {
+        dark: boolean;
+        items: import('./types').GlobalSearchResultInput;
+        timezone: string;
+        convertedDateFormat: string;
+        currentDateFormat: string;
+        isFixedPosition: boolean;
+        isHidden: boolean;
+        deep: boolean;
+    }, {}, import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {
+        eventListeners: import("./mixins/event-listeners").IEventListener[];
+    }, {
+        $addEventListener(event: string, cb: () => void, element?: Window & typeof globalThis): void;
+        $removeEventListener(event: string, cb: () => void, element?: Window & typeof globalThis): void;
+        $removeEventListeners(): void;
+    }, unknown, Record<never, any>, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>, import("vue").ComponentOptionsMixin>;
+    ESvgIcon: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, unknown, unknown, {
+        svgIconComponent: any;
+    }, {
+        icon: string;
+    }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+    ECalendarHeatmap: any;
+    EFlagIcon: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+    EImagePlayer: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {
+        src: string;
+        imageLoaded: boolean;
+        playing: boolean;
+        playerStyle: Record<string, string>;
+        image: HTMLImageElement | null;
+        previousSrc: string;
+        resolveImageLoadingPromise: (value?: any) => any;
+        preloadingQueueId: number;
+        preloadedFrames: number[];
+        preloadingFramesImgs: HTMLImageElement[];
+        frameError: boolean;
+        animationId: number;
+        imgStyle: Record<string, import("vue").StyleValue>;
+        previousFrameIndex: number;
+        isFullscreen: boolean;
+        mouseDownTime: number;
+        playPauseAnimation: boolean;
+        latestValidSnapshotTimestamp: string;
+        progressBar: HTMLDivElement | null;
+        isDraggingCursor: boolean;
+        hovered: boolean;
+        timePerFrameValue: number;
+        mousePosition: {
+            x: number;
+            y: number;
+        };
+        screenHeight: number;
+    }, {
+        getProgressBarMousePosition(e: any): {
+            x: number;
+            y: number;
+        };
+        onProgressBarMouseEnter(): void;
+        onProgressBarMouseMove(e: any): void;
+        onProgressBarMouseLeave(): void;
+        onProgressBarClick(): void;
+        getProgressBarChunkStyle(start: any, end: any): {
+            left: string;
+            width: string;
+        };
+        animatePlayPauseOverlay(): void;
+        isImageClick(e: PointerEvent): boolean;
+        onFrameMouseDown(e: PointerEvent): void;
+        onFrameMouseUp(e: PointerEvent): void;
+        removeFullscreenListeners(): void;
+        initializeFullscreenListeners(): void;
+        handleFullscreenChange(): void;
+        closeFullscreenMode(): void;
+        openFullscreenMode(): void;
+        toggleFullscreenMode(): void;
+        updateRefs(): void;
+        incrementCurrentFrameIndex(): void;
+        getFrameSrc(frame: import('./types').Frame): string | undefined;
+        loadTargetFrame(): Promise<unknown> | undefined;
+        handleBuffering(): Promise<void>;
+        buffer(): Promise<void>;
+        preloadFrames({ start, end }: {
+            start: number;
+            end: number;
+        }): Promise<void>;
+        delay(): Promise<void>;
+        cancelDelay(): void;
+        play(): Promise<void>;
+        flushPreloadingQueue(): void;
+        pause(): Promise<void>;
+        onLoad(): void;
+        onError(e: Event): import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>> | undefined;
+        onChange(obj: Record<string, any>): void;
+        onBeforeUpdate(e: Event): void;
+        onBeforeDestroy(e: Event): void;
+        togglePlay(): void;
+        handleKeyDown(e: KeyboardEvent): void;
+    }, {
+        imgProps: Record<string, string>;
+        playerDimensions: {
+            width: string;
+            height: string | number;
+        };
+        isLastFrame: boolean;
+        altText: string;
+        playedPercentage: number;
+        mouseToWidthRatio: number;
+        hoverBarStyle: {
+            width: string;
+        };
+        hoveredFrameIndex: number;
+        progressStyle: {
+            width: string;
+        };
+        preloadedChunks: number;
+    }, {
+        frames: import('./types').Frame[];
+        timePerFrame: number;
+        isPlaying: boolean;
+        frameIndex: number;
+        height: string | number;
+        initialQuality: string | number;
+        preload: boolean;
+        preloadSize: number;
+        resetIndexOnFramesChange: boolean;
+        preloadWhilePlaying: boolean;
+        withControls: boolean;
+        playOnClick: boolean;
+        disablePlayPauseAnimation: boolean;
+        disablePlayButton: boolean;
+        isLive: boolean;
+        selectedSnapshotQuality: string | number;
+        placeholderImage: string;
+        isMobile: boolean;
+        isZoomable: boolean;
+        isAnnotationActive: boolean;
+        aspectRatio: number;
+    }, {}, import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {
+        eventListeners: import("./mixins/event-listeners").IEventListener[];
+    }, {
+        $addEventListener(event: string, cb: () => void, element?: Window & typeof globalThis): void;
+        $removeEventListener(event: string, cb: () => void, element?: Window & typeof globalThis): void;
+        $removeEventListeners(): void;
+    }, unknown, Record<never, any>, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin> | import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {
+        timeouts: number[];
+    }, {
+        $setTimeout(cb: Function, timeout?: number): number;
+        $clearTimeouts(): void;
+    }, unknown, Record<never, any>, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>, import("vue").ComponentOptionsMixin>;
+    EZoomableImg: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {
+        image: HTMLImageElement | null;
+        frame: HTMLDivElement | null;
+        imageLoaded: boolean;
+        zoomLevel: number;
+        previousZoomLevel: number;
+        imageMouse: import("./components/EZoomableImg.vue").Point;
+        zoomOrigin: import("./components/EZoomableImg.vue").Point;
+        frameMouse: import("./components/EZoomableImg.vue").Point;
+        frameMousePanStart: import("./components/EZoomableImg.vue").Point;
+        frameMousePreviousPan: import("./components/EZoomableImg.vue").Point;
+        translation: import("./components/EZoomableImg.vue").Point;
+        isPanning: boolean;
+        isPinching: boolean;
+        zoomStarted: boolean;
+        firstLoad: boolean;
+        isSliderActive: boolean;
+        imgStyle: Record<string, import("vue").StyleValue>;
+        contentStyle: Record<string, import("vue").StyleValue>;
+        isFocused: boolean;
+        forceHideContent: boolean;
+        imageAspectRatio: number;
+        frameAspectRatio: number;
+        wrapperExtraStyle: Record<string, string>;
+        preventDefaultScroll: boolean;
+        mouseLeft: boolean;
+        pointers: Record<number, PointerEvent>;
+        pinchDistance: number;
+        lastTapTime: number;
+        minZoomLevel: number;
+        maxZoomLevel: number;
+        backgroundSnapshotSrc: string | null;
+    }, {
+        onResize(): void;
+        handleOrientationChange(): void;
+        setAspectRatio(): void;
+        updateImageStyle(): void;
+        updateMiniatureOverlayStyle(): void;
+        onImageLoaded(e: any): void;
+        onError(e: any): void;
+        onMouseEnter(): void;
+        onMouseLeave(): void;
+        onMouseMove(event: MouseEvent): void;
+        onMousedown(event: MouseEvent): void;
+        onMouseUp(event: MouseEvent): void;
+        onMouseWheel(event: WheelEvent): void;
+        updateZoomLevel(delta: number): void;
+        zoom(delta: number): void;
+        getBounds(): {
+            top: number;
+            right: number;
+            bottom: number;
+            left: number;
+        };
+        savePreviousPan({ x, y }?: {
+            x?: number | undefined;
+            y?: number | undefined;
+        }): void;
+        onSliderMouseDown(): void;
+        onSliderMouseUp(): void;
+        updateContentStyle(): void;
+        emitChange(): void;
+        getPointersMidPoint(a: PointerEvent, b: PointerEvent): {
+            x: number;
+            y: number;
+        };
+        getPointersDistance(a: PointerEvent, b: PointerEvent): number;
+        updatePointerEvent(e: PointerEvent): void;
+        clearPointerEvent(e: PointerEvent): void;
+        updatePinchZoomOrigin(): void;
+        updatePinchDistance(): void;
+        onPointerDown(e: PointerEvent): void;
+        onPointerMove(e: PointerEvent): void;
+        onPointerUp(e: PointerEvent): void;
+        getSnapshotSrc(): string;
+    }, {
+        frameStyle: Record<string, import("vue").StyleValue>;
+        wrapperStyle: {
+            display: string;
+            transform?: undefined;
+        } | {
+            transform: string;
+            display?: undefined;
+        };
+        imageCenter: {
+            x: number;
+            y: number;
+        };
+        sliderModel: number;
+        showContent: boolean;
+        miniatureContainerStyle: Record<string, string>;
+        miniatureOverlayComputedStyle: Record<string, string>;
+        miniatureOverlayBaseStyle: Record<string, string>;
+        currentState: {
+            image: HTMLImageElement | null;
+            zoomLevel: number;
+            translation: import("./components/EZoomableImg.vue").Point;
+            previousZoomLevel: number;
+            imageMouse: import("./components/EZoomableImg.vue").Point;
+            zoomOrigin: import("./components/EZoomableImg.vue").Point;
+            frameMouse: import("./components/EZoomableImg.vue").Point;
+            frameMousePanStart: import("./components/EZoomableImg.vue").Point;
+            frameMousePreviousPan: import("./components/EZoomableImg.vue").Point;
+            isPanning: boolean;
+            zoomStarted: boolean;
+            firstLoad: boolean;
+            isSliderActive: boolean;
+            imgStyle: Record<string, import("vue").StyleValue>;
+            contentStyle: Record<string, import("vue").StyleValue>;
+            isFocused: boolean;
+            forceHideContent: boolean;
+            imageAspectRatio: number;
+            frameAspectRatio: number;
+            wrapperExtraStyle: Record<string, string>;
+            offsetWidth: number | undefined;
+            offsetHeight: number | undefined;
+        };
+    }, {
+        src: string;
+        alt: string;
+        allowZoom: boolean;
+        imgProps: any;
+        slider: boolean;
+        disabled: boolean;
+        hideContentOnBlur: boolean;
+        initialParams: any;
+        embedded: boolean;
+        overlayStyle: any;
+        foregroundStyle: any;
+        pan: boolean;
+        slotTransition: boolean;
+        height: string | number;
+        isCalendarActive: boolean;
+        blurBackground: boolean;
+        cover: boolean;
+        isWidget: boolean;
+        isAnnotationActive: boolean;
+        isMobile: boolean;
+        placeholderImage: string;
+        showMiniature: boolean;
+        miniatureWidth: number;
+    }, {}, import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {
+        eventListeners: import("./mixins/event-listeners").IEventListener[];
+    }, {
+        $addEventListener(event: string, cb: () => void, element?: Window & typeof globalThis): void;
+        $removeEventListener(event: string, cb: () => void, element?: Window & typeof globalThis): void;
+        $removeEventListeners(): void;
+    }, unknown, Record<never, any>, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin> | import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {
+        timeouts: number[];
+    }, {
+        $setTimeout(cb: Function, timeout?: number): number;
+        $clearTimeouts(): void;
+    }, unknown, Record<never, any>, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>, import("vue").ComponentOptionsMixin>;
+    EZoomSlider: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, unknown, unknown, unknown, {
+        dark: boolean;
+    }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+    EActionButton: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, unknown, unknown, {
+        withTooltip: boolean;
+        buttonClassesContainsBg: boolean;
+        buttonStyle: string | string[];
+    }, {
+        tooltipText: string;
+        tooltipColor: string;
+        tooltipPosition: string;
+        buttonClasses: any;
+        icon: string;
+        iconSize: import('./types').Size;
+        iconColor: string;
+        dark: boolean;
+    }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+    ETooltip: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, unknown, unknown, {
+        tooltipClasses: Record<any, boolean>;
+        triangleClasses: Record<any, boolean>;
+    }, {
+        text: string;
+        position: import('./types').Position;
+        color: import('./types').BaseColor;
+        dark: boolean;
+    }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+    ELayout: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {
+        footerHeight: number;
+        overlayFooterHeight: number;
+        wrapperStyle: {
+            width: string;
+            height: string;
+        };
+        mainStyle: {
+            width: string;
+            height: string;
+        };
+        mainHeight: string;
+    }, {
+        onResize(): void;
+        onOverlayClick(e: Event): void;
+        setOverlayFooterHeight(): void;
+        setFooterHeight(): void;
+    }, {
+        bottomStyle: {
+            bottom: string;
+        };
+    }, {
+        height: string | number;
+        withOverlay: boolean;
+    }, {}, import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {
+        timeouts: number[];
+    }, {
+        $setTimeout(cb: Function, timeout?: number): number;
+        $clearTimeouts(): void;
+    }, unknown, Record<never, any>, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>, import("vue").ComponentOptionsMixin>;
+    EChat: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {
+        prompt: string;
+        containerHeight: number;
+        headerHeight: number;
+        bodyHeight: number;
+        footerHeight: number;
+    }, {
+        sendMessage(): void;
+        isUserMessage(message: import('./types').ChatMessage): boolean;
+        hasActions(message: import('./types').ChatMessage): boolean;
+        getMessageContent(message: import('./types').ChatMessage): string | string[];
+        getMessageInitials(message: import('./types').ChatMessage): string | null;
+        getMessageClasses(message: import('./types').ChatMessage, index: number): {
+            "e-mb-11": boolean;
+        };
+        updateChatBodyHeight(): void;
+        isAvatarVisible(message: import('./types').ChatMessage): boolean;
+        onMessageFeedback(feedback: import('./types').Feedback, messageId?: number | undefined): void;
+    }, {
+        ChatMessageRole: typeof import('./types').ChatMessageRole;
+        userInitials: string;
+        chatBodyStyle: Record<string, unknown>;
+        wrapperStyle: Record<string, unknown>;
+        bodyBorderClasses: Record<string, boolean>;
+        markdownScopedSlots: Record<string, import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>>;
+        showSuggestions: boolean;
+    }, {
+        dark: boolean;
+        messages: import('./types').ChatMessage[];
+        user: string;
+        embedded: boolean;
+        showHeader: boolean;
+        inlineFooter: boolean;
+        height: string;
+        width: string;
+        showUserAvatar: boolean;
+        showCopilotAvatar: boolean;
+        readonly: boolean;
+        isLoading: boolean;
+        isDisabled: boolean;
+        headerText: string;
+        inputPlaceholder: string;
+        loadingMessage: string;
+        suggestions: import('./types').ChatSuggestion[];
+        exposedRegexes: import('./types').EMarkdownRegex[];
+        eMarkdownProps: Record<string, unknown> | {
+            useTableProcessor: boolean;
+        };
+    }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+    EContextProvider: any;
+    ECopyToClipboardBtn: import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {
+        loading: boolean;
+        tooltipText: string;
+    }, {
+        handleFocusin(e: Event): void;
+        getProp(propName: string, fallback: any): any;
+        copyTextToClipboard(): void;
+    }, {
+        copyButtonClasses: Record<string, boolean>;
+    }, {
+        text: string | number | Function;
+        buttonText: string;
+        buttonClasses: any;
+        description: string;
+        iconType: string;
+        textOnlyButton: boolean;
+        dark: boolean;
+    }, {}, import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {
+        eventListeners: import("./mixins/event-listeners").IEventListener[];
+    }, {
+        $addEventListener(event: string, cb: () => void, element?: Window & typeof globalThis): void;
+        $removeEventListener(event: string, cb: () => void, element?: Window & typeof globalThis): void;
+        $removeEventListeners(): void;
+    }, unknown, Record<never, any>, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin> | import("vue/types/vue").ExtendedVue<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {
+        timeouts: number[];
+    }, {
+        $setTimeout(cb: Function, timeout?: number): number;
+        $clearTimeouts(): void;
+    }, unknown, Record<never, any>, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>, import("vue").ComponentOptionsMixin>;
+};
+declare const _default: {
+    install(Vue: VueConstructor): void;
+};
+export default _default;
+export { EAvatar, EBadge, EIcon, ESpinner, ERow, ECol, EVideoPlayer, ETimeline, EVideoEmbed, EHeatmapBar, EHoursHeatmap, EReadMore, ETruncatedDiv, ECompareSeparator, EImagesComparator, EToggleSwitch, EExpandableMenu, EZoomable, EGlobalSearch, ESvgIcon, ECalendarHeatmap, EFlagIcon, EImagePlayer, EZoomableImg, EZoomSlider, EActionButton, ETooltip, ELayout, ECopyToClipboardBtn, };
+export * from './constants';
+export * from './types';
+export * from './utils';
+export * from './directives';
+export * from './mixins';