@evercam/ui 0.0.62 → 0.0.63-Add-timeline-tests-1aaeb4ea7

package/dist/index.d.ts

@@ -5,22 +5,35 @@ 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/ETimeline.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';
+import EVoiceRecorderToText from './components/EVoiceInput.vue';
+import ERadioGroup from './components/ERadioGroup.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;
@@ -37,6 +50,7 @@ export declare const components: {
         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: {
@@ -185,7 +199,6 @@ export declare const components: {
     }, {
         posterUrl: string;
         sourceItems: import('./components/EVideoPlayer.vue').VideoSource[];
-        hasStartedOrFinished: boolean;
         withControls: "" | "hide";
     }, {
         targetTimestamp: string;
@@ -210,109 +223,67 @@ export declare const components: {
         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;
-        cursor: HTMLElement;
         timeline: HTMLElement;
         wrapperDiv: HTMLElement;
-        selectedTimestampCursor: HTMLElement;
+        svgElement: SVGSVGElement;
         svg: import("d3-selection").Selection<SVGSVGElement, any, any, any>;
-        axesContainer: import("d3-selection").Selection<SVGGElement, any, any, any>;
-        xAxes: Record<import('./types').TimelineAxis, import("d3-axis").Axis<Date>>;
         timeScale: import("d3-scale").ScaleTime<any, any, unknown>;
-        initialTimeScale: import("d3-scale").ScaleTime<any, any, unknown>;
         currentTimeScaleDensity: number;
-        zoomBehavior: import("d3-zoom").ZoomBehavior<SVGSVGElement, unknown>;
-        isMouseDown: boolean;
         axisHeight: number;
         isHoveringEvent: boolean;
         hoveredEvent: import('./types').TimelineEvent;
-        isHoveringTimeline: boolean;
-        hoveredTimestamp: string;
         eventTooltipStyle: {};
         hoveredEventType: string;
         utcOffset: number;
-        lastTransform: {
-            x: number;
-            k: number;
-        };
-        transformDiff: {
-            translation: number;
-            scale: 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>;
-        markersPositions: Record<string, {
-            position: number;
-            isHidden: boolean;
-        }>;
-        markersDragBehavior: import("d3-drag").DragBehavior<HTMLElement, import('./types').TimelineMarker, any>;
-        initialMarkerDragMouseOffset: number;
         selectedMilestoneId: any;
         isInitialized: boolean;
-        lastValidTransform: import("d3-zoom").ZoomTransform;
-        lastPanTransform: import("d3-zoom").ZoomTransform;
-        isZoomingInterval: boolean;
-        defs: {
-            transparencyGradient: string;
-            transparencyGradientLight: string;
-            loadingGradient: string;
-            stripedPattern: string;
+        transformDiff: {
+            translation: number;
+            scale: number;
         };
+        isZoomingInterval: boolean;
+        hoveredMilestone: import('./types').TimelineEvent;
+        focusedDomain: import('./types').TimelineDomain;
+        transitionDuration: number;
+        focusedTimestamp: string | Date;
+        TimelineChartType: typeof import('./types').TimelineChartType;
     }, {
+        validateProps(): void;
         updateTimeline(): void;
-        initTimeline(startDate?: string | undefined, endDate?: string | undefined): void;
+        initTimeline(): void;
         initRefs(): void;
         initOrUpdateSvg(): void;
-        initDefs(): void;
         initUtcOffset(): void;
-        initTimeScale(start?: string | undefined, end?: string | undefined): void;
-        initXAxes(): void;
-        updateXAxes(): void;
         initYScale(): void;
-        updateYScaleDomain(): void;
-        initZoomBehavior(): void;
+        updateYScale(): void;
         zoomToFitMarkers(): void;
-        zoomToTargetInterval(start?: string | number | undefined, end?: string | number | undefined): void;
-        translateIntervalIntoView(minTimestamp: number, maxTimestamp: number, scaleFactor: number): void;
-        initSelectedTimestampCursor(): void;
-        updateMarkers(): void;
-        updateAndRedrawTimeline(): void;
         clearTimeline(): void;
-        repositionSelectedTimestampCursor(): void;
         updateCurrentTimeScaleDensity(): void;
-        registerEventsListeners(): void;
         emitVisibleInterval(trigger: import('./types').TimelineIntervalChangeTrigger): void;
-        createAxis(axisName: import('./types').TimelineAxis): import("d3-axis").Axis<Date>;
-        getAxisTicksConfig(configs: import('./types').TimelineTicksConfig[]): {
-            formatFn: (d: Date) => string;
-            interval: any;
-        };
         onResize(resizeObserverEntry: ResizeObserverEntry): void;
         handleResize({ contentRect }: ResizeObserverEntry): void;
         handleDarkModeChange(): void;
-        handleMouseDown(): void;
-        handleDocumentMouseUp(_e: MouseEvent): void;
         handleMouseLeave(): void;
-        handleMouseMove(event: MouseEvent): void;
-        handleClick(event: MouseEvent): 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;
@@ -320,40 +291,17 @@ export declare const components: {
         handleBarMouseOut(): void;
         handleLabelMouseOver(groupType: string): void;
         handleLabelMouseLeave(groupType: string): void;
-        isZoomAllowed(event: import("d3-zoom").D3ZoomEvent<SVGSVGElement, any>): boolean;
-        handleZoom(event: import("d3-zoom").D3ZoomEvent<SVGSVGElement, any>): void;
-        panToTimestamp(targetTimestamp: string | Date): 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;
+        handleTransformChange(transform: {
+            translation: number;
+            scale: number;
+        }): void;
+        handleTimeScaleChange(ts: import("d3-scale").ScaleTime<any, any, unknown>): void;
         zoomToStartAndEndDates(): void;
-        rescaleAxis(axisName: string, newScale: import("d3-scale").ScaleTime<any, any, unknown>): void;
-        translateTicksText(axisName: string): 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;
-        isTimestampAllowedForMarker(timestamp: number | Date, marker: import('./types').TimelineMarker): boolean;
-        handleMarkerDrag({ marker, markerElement, dragEvent, }: {
-            marker: import('./types').TimelineMarker;
-            markerElement: import("d3-selection").Selection<any, import('./types').TimelineMarker, any, any>;
-            dragEvent: import("d3-drag").D3DragEvent<any, import('./types').TimelineMarker, any>;
-        }): void;
-        removeMarkersDragBehavior(): void;
-        initMarkersDragBehavior(): void;
-        initCurtains(): void;
-        createCurtains(): void;
-        updateCurtains(): void;
         updateForbiddenIntervals(reset?: boolean): void;
         drawEventsGroups(): void;
         drawLineGraphEventsGroups(): void;
@@ -369,25 +317,14 @@ export declare const components: {
             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;
+        getMilestoneGroupYPosition(groupName: string | number): number;
+        getBarGroupYPosition(groupName: string | number, bottom?: boolean | undefined): number;
         getBarGroupHeight(eventsGroup: import('./types').TimelineEventsGroup): number;
-        updateMilestonesPositions(): void;
         drawBarChartEventsGroups(): void;
         drawProgressIndicator({ yPosition, type, isLoading, }: {
             yPosition: number;
@@ -395,23 +332,6 @@ export declare const components: {
             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>;
@@ -438,22 +358,12 @@ export declare const components: {
             background: string;
             color: string;
         };
+        getExternalLabelText(type: string): string;
         getExternalLabelWrapperStyles(type: string): {
             borderColor: string;
         };
-        getMarkerClass(marker: import('./types').TimelineMarker): {
-            "marker--hidden": boolean;
-            "marker--draggable": boolean | undefined;
-        };
-        getMarkerContainerStyle(marker: import('./types').TimelineMarker): Record<string, string>;
-        getMarkerLabelStyle(marker: import('./types').TimelineMarker): Record<string, string>;
-        getMarkerLineStyle(marker: import('./types').TimelineMarker): Record<string, string>;
         tzStringToDate(timestamp: import('./types').Timestamp): Date;
         dateToTzString(date: Date): string;
-        getCurrentTimeBounds(): {
-            startDate: string;
-            endDate: string;
-        };
         getFormattedTimestamp(timestamp: import('./types').Timestamp): string;
         fillTimeGaps(events: import('./types').TimelineEvent[]): (import('./types').TimelineBarEvent | import('./types').TimelineRangeEvent | import('./types').TimelineCountEvent | {
             timestamp: string;
@@ -462,6 +372,7 @@ export declare const components: {
         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;
@@ -471,7 +382,7 @@ export declare const components: {
         barsYOffset: number;
         hasMilestones: boolean;
         barChartHeight: number;
-        classes: Record<string, string | Record<string, boolean>>;
+        computedClasses: Record<string, string | Record<string, boolean>>;
         lineGraphGroups: import('./types').TimelineEventsByType;
         chartHeight: number;
         barGroups: import('./types').TimelineEventsByType;
@@ -480,6 +391,7 @@ export declare const components: {
         hasChart: boolean;
         labelRectWidth: number;
         combinedXAxesHeight: number;
+        timelineWidth: number;
         timelineHeight: number;
         filteredEventsGroups: import('./types').TimelineEventsByType;
         allEventsSorted: import('./types').TimelineEvent[];
@@ -488,14 +400,20 @@ export declare const components: {
         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;
+        milestonesGroupsPlaceholder: import('./types').TimelineEventsByType;
     }, {
-        eventsGroups: {};
-        xAxesConfig: import('./types').TimelineAxesConfig;
+        eventsGroups: import('./types').TimelineEventsByType;
         dark: boolean;
         startDate: string;
         endDate: string;
@@ -504,7 +422,6 @@ export declare const components: {
         disableZoom: boolean;
         insertZerosAtInterval: import('./types').TimelinePrecision;
         flattenLineGraphEnds: boolean;
-        curtains: boolean;
         showLabels: boolean;
         rectMinWidth: number;
         barHeight: number;
@@ -512,11 +429,8 @@ export declare const components: {
         barXPadding: number;
         chartMinHeight: number;
         chartMinLabelHeight: number;
-        minZoom: number;
-        maxZoom: number;
         minDate: string;
         maxDate: string;
-        cursorTimestamp: string | undefined;
         selectedClass: string | undefined;
         panOnDateClick: boolean;
         panTransitionDuration: number;
@@ -535,6 +449,9 @@ export declare const components: {
         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;
@@ -545,23 +462,34 @@ export declare const components: {
         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>>, unknown, {
+    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: unknown[];
+        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;
@@ -609,39 +537,73 @@ export declare const components: {
     }, {
         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>>, {
-        value: any;
+        checkedIndex: number | null;
     }, {
-        getButtonClasses(optionValue: any): {
-            "e-border-none": boolean;
+        setInitialValue(): void;
+        getButtonClasses(index: number): {
+            "e-border-none e-text-gray-100 e-rounded-md e-shadow e-transition e-duration-200 e-ease-in-out e-cursor-pointer": 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;
+        isSelected(index: number): boolean;
+        onItemClick(index: number): void;
     }, {
+        selectedOption: Record<string, any>;
         sizeClasses: {
-            container: import('./components/EToggleSwitch.vue').CssClassMap;
-            button: import('./components/EToggleSwitch.vue').CssClassMap;
-            text: import('./components/EToggleSwitch.vue').CssClassMap;
+            container: import('./types').CssClassMap;
+            button: import('./types').CssClassMap;
+            text: import('./types').CssClassMap;
         };
-        containerClasses: import('./components/EToggleSwitch.vue').CssClassMap;
-        textClasses: import('./components/EToggleSwitch.vue').CssClassMap;
-        buttonBaseClasses: import('./components/EToggleSwitch.vue').CssClassMap;
+        containerClasses: import('./types').CssClassMap;
+        textClasses: import('./types').CssClassMap;
     }, {
-        options: import('./components/EToggleSwitch.vue').EToggleSwitchOption[];
+        options: import('./types').ESelectionGroupOption[];
         color: string;
         size: import('./types').Size;
-        defaultValue: string | number | boolean;
+        value: string | number | boolean;
+        disabled: 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;
+        isMenuOpened: boolean;
         touched: boolean;
         baseSize: {};
+        menuObserver: MutationObserver;
     }, {
         toggleMenu(): void;
-        setButtonsPositions(open?: boolean | undefined): void;
+        adjustButtonsPositions(): void;
+        observeMenuContentChanges(): void;
     }, {
         row: boolean;
         reverse: boolean;
@@ -650,15 +612,16 @@ export declare const components: {
         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>>, {
-        timeouts: number[];
-    }, {
-        $setTimeout(cb: Function, timeout?: number): number;
-        $clearTimeouts(): 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>>, {
         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;
@@ -730,6 +693,7 @@ export declare const components: {
         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, {
@@ -737,12 +701,492 @@ export declare const components: {
     }, {
         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;
+        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;
+        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;
+        preloadingQueueId: 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[] | Record<string, unknown>;
+        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/types/vnode").NormalizedScopedSlot | undefined>;
+        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;
+        };
+        silenceTimeout: number;
+    }, {}, 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>;
+    EVoiceRecorderToText: 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>>, {
+        recognition: any;
+        isListening: boolean;
+        interimTranscript: string;
+        finalTranscript: string;
+        analyser: AnalyserNode | null;
+        audioContext: AudioContext | null;
+        mediaStream: MediaStream | null;
+        mediaStreamSource: MediaStreamAudioSourceNode | null;
+        silenceTimer: number | null;
+    }, {
+        initSpeechRecognition(): void;
+        toggleListening(): Promise<void>;
+        setupVolume(): Promise<void>;
+        stopListening(): void;
+        flushMediaStream(): void;
+        handleResult(event: Event & {
+            resultIndex: number;
+            results: {
+                [key: number]: {
+                    transcript: string;
+                };
+                isFinal: boolean;
+            }[];
+        }): void;
+        handleEnd(): void;
+        handleSpeechEnd(): void;
+        submitTranscript(): void;
+        handleKeyDown(event: KeyboardEvent): void;
+        handleError(event: Record<string, string>): void;
+    }, {
+        currentTranscript: string;
+        buttonClasses: Record<string, boolean>;
+    }, {
+        value: string;
+        dark: boolean;
+        disabled: boolean;
+        iconSize: number;
+        silenceTimeout: 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").ComponentOptionsMixin>;
+    ERadioGroup: 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>>, {
+        checkedIndex: number | null;
+    }, {
+        setInitialValueIfNone(): void;
+        onItemClick(index: number): void;
+        isSelected(index: number): boolean;
+        showDescription(index: number): boolean;
+        containerClasses(index: number): (string | Record<string, boolean>)[];
+    }, {
+        selectedOption: import('./types').ERadioGroupOption;
+        radioItemClasses: Record<string, boolean>;
+        selectedItemClasses: string;
+    }, {
+        dark: boolean;
+        value: string | number | boolean;
+        options: import('./types').ERadioGroupOption[];
+        disabled: boolean;
+        withDescription: boolean;
+    }, {}, 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, EToggleSwitch, EExpandableMenu, EZoomable, EGlobalSearch, ESvgIcon, };
+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, EVoiceRecorderToText, ERadioGroup, };
 export * from './constants';
 export * from './types';
 export * from './utils';