@evercam/ui 0.0.65 → 1.0.0-137f13197

package/dist/index.d.ts

@@ -5,7 +5,7 @@ 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';
@@ -16,14 +16,27 @@ 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 ESchedulePicker from './components/ESchedulePicker.vue';
+import ESelect from './components/ESelect.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';
+import ETabs from './components/ETabs.vue';
+import EPopover from './components/EPopover.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;
@@ -40,6 +53,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: {
@@ -188,18 +202,21 @@ export declare const components: {
     }, {
         posterUrl: string;
         sourceItems: import('./components/EVideoPlayer.vue').VideoSource[];
-        hasStartedOrFinished: boolean;
         withControls: "" | "hide";
+        streamingToken: string;
     }, {
         targetTimestamp: string;
         sources: string | import('./components/EVideoPlayer.vue').VideoSource[];
         videoListeners: {};
         videoOptions: {};
         isHls: boolean;
-        streamingToken: string;
+        isEdgeVideo: boolean;
+        edgeStreamingToken: string;
+        authToken: string;
         pauseOnClick: boolean;
         isHlsLoading: boolean;
         isPlaying: boolean;
+        showLoadingAnimation: boolean;
         isZoomable: boolean;
         zoomableIgnorePointerEvents: boolean;
         timezone: string;
@@ -213,231 +230,75 @@ 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;
+        isHoveringGroupedEvents: boolean;
+        isAnimating: 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;
-        };
-    }, {
-        updateTimeline(): void;
-        initTimeline(startDate?: string | undefined, endDate?: string | undefined): void;
+        hoveredMilestone: import('./types').TimelineEvent;
+        focusedDomain: import('./types').TimelineDomain;
+        transitionDuration: number;
+        focusedTimestamp: string | Date;
+        hoveredGroupedEvents: import('./types').TimelineEvent[];
+        TimelineChartType: typeof import('./types').TimelineChartType;
+        width: number;
+    }, {
+        handleVisibleIntervalChange({ fromDate, toDate, trigger, transform }: {
+            fromDate: any;
+            toDate: any;
+            trigger: any;
+            transform: any;
+        }): void;
+        getGroupByType(groups: import('./types').TimelineEventsByType, types: import('./types').TimelineChartType[]): {};
+        getPreviousCountsByTimestamp(index: number): Record<string, number>;
+        getChartsYPosition(groupId: string | number): number;
+        validateProps(): void;
+        initTimeline(): void;
         initRefs(): void;
-        initOrUpdateSvg(): void;
-        initOrUpdateDefs(): void;
-        initUtcOffset(): void;
-        initTimeScale(start?: string | undefined, end?: string | undefined): void;
-        initXAxes(): void;
-        updateXAxes(): void;
-        initYScale(): void;
-        updateYScale(): void;
-        initZoomBehavior(): 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;
-        selectOrAppend({ parent, targetId, targetType, }: {
-            parent: any;
-            selector: string;
-            nodeType: string;
-        }): any;
-        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;
+        isForbiddenInterval(timestamp: string): boolean;
+        handleClick(timestamp: string): void;
         handleMarkerClick(marker: import('./types').TimelineMarker): void;
-        handleLineMouseOver(_event: MouseEvent, eventData: import('./types').TimelineCountEvent, eventType: string): void;
-        handleLineMouseOut(): void;
+        handleChartMouseOver(_event: MouseEvent, eventData: import('./types').TimelineCountEvent, eventType: string): void;
+        handleChartMouseOut(): void;
         handleBarMouseOver(event: MouseEvent, eventData: import('./types').TimelineEvent, eventType: string): void;
+        handleBarGroupedEventsMouseOver(event: MouseEvent, events: import('./types').TimelineEvent[], eventType: string): void;
         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;
+        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;
-        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;
+        onAnimationStart(): void;
+        onAnimationEnd(): 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;
-            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;
@@ -446,31 +307,28 @@ 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 | {
+        fillTimeGaps(events: import('./types').TimelineEvent[]): (import('./types').TimelineBarEvent | import('./types').TimelineRangeEvent | import('./types').TimelineCountEvent | import('./types').TimelineMilestoneEvent | {
             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;
+        onResizeContainer({ contentRect }: ResizeObserverEntry): void;
     }, {
+        filteredEventsGroups: import('./types').TimelineEventsByType;
+        allEventsSorted: import('./types').TimelineEvent[];
+        barGroups: import('./types').TimelineEventsByType;
+        lineGraphGroups: import('./types').TimelineEventsByType;
+        barChartGroups: import('./types').TimelineEventsByType;
+        milestonesGroups: import('./types').TimelineEventsByType;
         combinedBarsHeight: number;
         combinedBottomBarsHeight: number;
         combinedMilestonesHeight: number;
@@ -478,64 +336,53 @@ export declare const components: {
         chartsYOffset: number;
         barsYOffset: number;
         hasMilestones: boolean;
-        barChartHeight: number;
-        classes: Record<string, string | Record<string, boolean>>;
-        lineGraphGroups: import('./types').TimelineEventsByType;
+        computedClasses: Record<string, string | Record<string, boolean>>;
         chartHeight: number;
-        barGroups: import('./types').TimelineEventsByType;
-        barChartGroups: import('./types').TimelineEventsByType;
-        milestonesGroups: import('./types').TimelineEventsByType;
+        chartLabelHeight: number;
         hasChart: boolean;
         labelRectWidth: number;
         combinedXAxesHeight: 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[];
+        flattenedLinesCounts: import('./types').TimelineCountEvent[];
+        flattenedBarsCounts: 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;
+        countsByTimestamp: Record<string, Record<string, number>>;
     }, {
-        eventsGroups: {};
-        xAxesConfig: import('./types').TimelineAxesConfig;
+        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;
-        minZoom: number;
-        maxZoom: number;
         minDate: string;
         maxDate: string;
-        cursorTimestamp: string | undefined;
-        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[];
@@ -545,6 +392,8 @@ export declare const components: {
         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;
@@ -555,23 +404,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;
@@ -607,6 +467,7 @@ export declare const components: {
         expandText: string;
         collapseText: string;
         moreTextWithPlaceholder: string;
+        onePerLine: boolean;
     }, {}, 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>;
@@ -648,39 +509,70 @@ export declare const components: {
         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;
-    }, {
-        getButtonClasses(optionValue: any): {
-            "e-border-none": boolean;
+    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, {
+        getButtonClasses(item: import('./types').ESelectionGroupOption): {
+            "e-toggle-switch 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;
+            "e-opacity-50 e-cursor-not-allowed": boolean | undefined;
         };
-        handleClick(value: any): void;
     }, {
         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;
+        wrapperClasses: import('./types').CssClassMap;
+        textClasses: import('./types').CssClassMap;
     }, {
-        options: import('./components/EToggleSwitch.vue').EToggleSwitchOption[];
         color: string;
         size: import('./types').Size;
-        defaultValue: string | number | boolean;
-    }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+        vertical: 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>>, unknown, {
+        isSelected(value: any): boolean;
+        onItemClick(value: any): void;
+        selectAll(): void;
+        deselectAll(): void;
+        toggleSelectAll(): void;
+        getOptionByValue(value: number): import('./types').ESelectionGroupOption | null;
+        containerClasses(item: import('./types').ESelectionGroupOption): (string | Record<string, boolean> | (string | Record<string, boolean>)[])[];
+    }, {
+        selectedOption: import('./types').ESelectionGroupOption | import('./types').ESelectionGroupOption[] | null;
+        localLabel: string | null;
+        isAllSelected: boolean;
+        isAtLeastOneSelected: boolean;
+        radioItemClasses: Record<string, boolean>;
+        selectedItemClasses: (string | Record<string, boolean>)[];
+        isValueProvided: boolean;
+    }, {
+        options: import('./types').ESelectionGroupOption[] | import('./types').ERadioGroupOption[];
+        setInitialValue: boolean;
+        multiple: 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>>, {
+        currentValue: any;
+    }, unknown, unknown, {
+        value: any;
+        label: string;
+        disabled: boolean;
+        type: string;
+        required: boolean;
+        errors: String[];
+    }, {}, 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>>, {
+        isOpen: boolean;
+        selectId: string;
+    }, {
+        toggleOpen(event: Event): void;
+    }, unknown, Record<never, any>, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>, 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;
+        isMenuOpened: boolean;
         baseSize: {};
+        menuObserver: MutationObserver;
     }, {
         toggleMenu(): void;
-        setButtonsPositions(open?: boolean | undefined): void;
+        adjustButtonsPositions(): void;
+        observeMenuContentChanges(): void;
     }, {
         row: boolean;
         reverse: boolean;
@@ -689,16 +581,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;
@@ -779,13 +671,639 @@ 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>>, {
+        isHovered: boolean;
+    }, {
+        toggleTooltip(): void;
+    }, {
+        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>;
+    EPopover: 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, {
+        closePopover(): void;
+    }, {
+        panelThemeClasses: Record<string, boolean>;
+    }, {
+        dark: boolean;
+        label: string;
+        panelSide: string;
+        panelClasses: {};
+    }, {}, 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>>, {
+        isOpen: boolean;
+        selectId: string;
+    }, {
+        toggleOpen(event: Event): 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>>, unknown, {
+        showDescription(index: number): any;
+        containerClasses(index: number): (string | Record<string, boolean>)[];
+    }, {
+        radioItemClasses: Record<string, boolean>;
+        selectedItemClasses: string;
+    }, {
+        dark: boolean;
+        withDescription: 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>>, unknown, {
+        isSelected(value: any): boolean;
+        onItemClick(value: any): void;
+        selectAll(): void;
+        deselectAll(): void;
+        toggleSelectAll(): void;
+        getOptionByValue(value: number): import('./types').ESelectionGroupOption | null;
+        containerClasses(item: import('./types').ESelectionGroupOption): (string | Record<string, boolean> | (string | Record<string, boolean>)[])[];
+    }, {
+        selectedOption: import('./types').ESelectionGroupOption | import('./types').ESelectionGroupOption[] | null;
+        localLabel: string | null;
+        isAllSelected: boolean;
+        isAtLeastOneSelected: boolean;
+        radioItemClasses: Record<string, boolean>;
+        selectedItemClasses: (string | Record<string, boolean>)[];
+        isValueProvided: boolean;
+    }, {
+        options: import('./types').ESelectionGroupOption[] | import('./types').ERadioGroupOption[];
+        setInitialValue: boolean;
+        multiple: 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>>, {
+        currentValue: any;
+    }, unknown, unknown, {
+        value: any;
+        label: string;
+        disabled: boolean;
+        type: string;
+        required: boolean;
+        errors: String[];
+    }, {}, 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>>, {
+        isOpen: boolean;
+        selectId: string;
+    }, {
+        toggleOpen(event: Event): void;
+    }, unknown, Record<never, any>, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>, import("vue").ComponentOptionsMixin>, import("vue").ComponentOptionsMixin>;
+    ESelect: 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>>, {
+        searchQuery: string;
+        menuStyle: {};
+    }, {
+        handleTriggerClick(e: Event, callback: (e: Event) => void): void;
+        handleMenuStyle(): void;
+        clearSearch(): void;
+    }, {
+        customLabel: string;
+        filteredOptions: import('./types').ESelectionGroupOption[];
+        scrollbarClasses: Record<string, boolean>;
+        showSearchClearButton: boolean;
+    }, {
+        dark: boolean;
+        withSelectAll: boolean;
+        customSelectionLabel: string;
+        name: string;
+        label: string;
+        withCheckbox: boolean;
+        searchable: boolean;
+        searchPlaceholder: string;
+        withSearchQueryVisible: 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>>, unknown, {
+        isSelected(value: any): boolean;
+        onItemClick(value: any): void;
+        selectAll(): void;
+        deselectAll(): void;
+        toggleSelectAll(): void;
+        getOptionByValue(value: number): import('./types').ESelectionGroupOption | null;
+        containerClasses(item: import('./types').ESelectionGroupOption): (string | Record<string, boolean> | (string | Record<string, boolean>)[])[];
+    }, {
+        selectedOption: import('./types').ESelectionGroupOption | import('./types').ESelectionGroupOption[] | null;
+        localLabel: string | null;
+        isAllSelected: boolean;
+        isAtLeastOneSelected: boolean;
+        radioItemClasses: Record<string, boolean>;
+        selectedItemClasses: (string | Record<string, boolean>)[];
+        isValueProvided: boolean;
+    }, {
+        options: import('./types').ESelectionGroupOption[] | import('./types').ERadioGroupOption[];
+        setInitialValue: boolean;
+        multiple: 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>>, {
+        currentValue: any;
+    }, unknown, unknown, {
+        value: any;
+        label: string;
+        disabled: boolean;
+        type: string;
+        required: boolean;
+        errors: String[];
+    }, {}, 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>>, {
+        isOpen: boolean;
+        selectId: string;
+    }, {
+        toggleOpen(event: Event): void;
+    }, unknown, Record<never, any>, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>, import("vue").ComponentOptionsMixin>, import("vue").ComponentOptionsMixin>;
+    ETabs: 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, {
+        onTabSelected(index: number): void;
+        isActive(index: number): boolean;
+        isLink(link: string): boolean;
+        isExternalLink(link: string): boolean;
+        getTabBarItemClasses(index: number, link?: string): (string | Record<string, boolean>)[];
+        getChildTitle(child: import("vue").VNode): string;
+        renderTab(h: import("vue").CreateElement, child: import("vue").VNode, index: number): import("vue").VNode;
+        renderContent(h: import("vue").CreateElement, child: import("vue").VNode, index: number): import("vue").VNode | null;
+    }, unknown, {
+        dark: boolean;
+        vertical: boolean;
+        activeClass: string;
+    }, {}, 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>>, {
+        currentValue: any;
+    }, unknown, unknown, {
+        value: any;
+        label: string;
+        disabled: boolean;
+        type: string;
+        required: boolean;
+        errors: String[];
+    }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>, import("vue").ComponentOptionsMixin>;
+    ECard: 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, Record<never, any>, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin>;
+    ESchedulePicker: 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>>, {
+        min: number;
+        max: number;
+        enabledDays: {
+            [day: string]: boolean;
+        };
+        schedule: Record<string, [number, number]>;
+        hours: number[];
+    }, {
+        initEnabledDays(): void;
+        toTextSchedule(): {
+            [k: string]: string[];
+        };
+        changeSchedule(): void;
+        onHoursChange(newRange: number[]): void;
+    }, {
+        isDisabled: boolean;
+    }, {
+        scheduleType: string;
+        preloadSchedule: string | import('./types').Schedule;
+        editMode: boolean;
+        dark: boolean;
+        step: number;
+    }, {}, 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, };
+export { EAvatar, EBadge, EIcon, ESpinner, ERow, ECol, EVideoPlayer, ETimeline, EVideoEmbed, EHeatmapBar, EHoursHeatmap, EReadMore, ETruncatedDiv, ECompareSeparator, EImagesComparator, EToggleSwitch, EExpandableMenu, EZoomable, EGlobalSearch, ESvgIcon, ECalendarHeatmap, EImagePlayer, EZoomableImg, EZoomSlider, EActionButton, ETooltip, ELayout, ECopyToClipboardBtn, EPopover, EVoiceRecorderToText, ERadioGroup, ESelect, ETabs, ESchedulePicker, };
 export * from './constants';
 export * from './types';
 export * from './utils';